Attachment #336388 for bug #453420

View | Details | Raw Unified | Return to bug 453420
Collapse All | Expand All




#include <llvm/Module.h>
#include <llvm/Value.h>
#include <llvm/Type.h>
#ifdef LLVM_27_OR_28
#include <llvm/System/Path.h>
#else
#include <llvm/Support/Path.h>
#endif
#include <llvm/Support/raw_ostream.h>

#include "Function.h"

#endif

namespace llvm {
// Printing of types.
static inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
  T.print(OS);
  return OS;
}
#define MAKE_OPERATOR(_type_)                                             \
  std::ostream& operator<< (std::ostream& ostr, const llvm::_type_& val)  \
  {                                                                       \
    std::string str;                                                      \
    llvm::raw_string_ostream rs(str);                                     \
    rs << val;                                                            \
    rs.flush();                                                           \
    ostr << str;                                                          \
    return ostr;                                                          \

Lines 78-85 Link Here

(-)a/CMakeLists.txt (-2 / +2 lines)
78	FIND_LLVM_LIBS( ${LLVM_CONFIG_EXECUTABLE} "native bitwriter linker bitreader jit interpreter support ipo" LLVM_LIBS LLVM_NATIVE_OBJECTS )	78	FIND_LLVM_LIBS( ${LLVM_CONFIG_EXECUTABLE} "native bitwriter linker bitreader jit interpreter support ipo" LLVM_LIBS LLVM_NATIVE_OBJECTS )
79	endif(MSVC)	79	endif(MSVC)
80		80
81	if( NOT MSVC AND NOT (LLVM_VERSION STREQUAL "3.1" OR LLVM_VERSION STREQUAL "3.0" ) ) # There is no way with MSVC to know the llvm version	81	if( NOT MSVC AND NOT (LLVM_VERSION STREQUAL "3.1" OR LLVM_VERSION STREQUAL "3.0" OR LLVM_VERSION STREQUAL "3.2svn" OR LLVM_VERSION STREQUAL "3.2" ) ) # There is no way with MSVC to know the llvm version
82	message(FATAL_ERROR "LLVM 3.0 or 3.1 is required.")	82	message(FATAL_ERROR "LLVM 3.0 or 3.1 or 3.2 is required.")
83	endif()	83	endif()
84		84
85	if(MSVC)	85	if(MSVC)

Lines 29-35 Link Here

(-)a/OpenCTL/OpenCTL/Program.cpp (-1 lines)
29	#include <llvm/PassManager.h>	29	#include <llvm/PassManager.h>
30	#include <llvm/Analysis/LoopPass.h>	30	#include <llvm/Analysis/LoopPass.h>
31	#include <llvm/Analysis/Verifier.h>	31	#include <llvm/Analysis/Verifier.h>
32	#include <llvm/Target/TargetData.h>
33	#include <llvm/GlobalVariable.h>	32	#include <llvm/GlobalVariable.h>
34		33
35	// GTLCore	34	// GTLCore

Lines 287-293 Link Here

(-)a/OpenGTL/GTLCore/AST/Statement.cpp (-1 / +1 lines)
287	std::vector<llvm::Type*> params;	287	std::vector<llvm::Type*> params;
288	params.push_back( llvm::Type::getInt32Ty(_context.llvmContext()));	288	params.push_back( llvm::Type::getInt32Ty(_context.llvmContext()));
289	llvm::FunctionType* definitionType = llvm::FunctionType::get( llvm::Type::getVoidTy(_context.llvmContext()), params, true );	289	llvm::FunctionType* definitionType = llvm::FunctionType::get( llvm::Type::getVoidTy(_context.llvmContext()), params, true );
290	llvm::Function* func = dynamic_cast<llvm::Function*>( _context.llvmModule()->getOrInsertFunction("print", definitionType));	290	llvm::Function* func = llvm::dyn_cast<llvm::Function>( _context.llvmModule()->getOrInsertFunction("print", definitionType));
291		291
292	std::vector<llvm::Value*> values;	292	std::vector<llvm::Value*> values;
293	values.push_back( _context.codeGenerator()->integerToConstant( _context.llvmContext(), gtl_uint32(m_expressions.size()) ));	293	values.push_back( _context.codeGenerator()->integerToConstant( _context.llvmContext(), gtl_uint32(m_expressions.size()) ));

Lines 77-83 Link Here

(-)a/OpenGTL/GTLCore/Function_p.cpp (-2 / +2 lines)
77	const llvm::Function* func = _functionToCopy->d->data->function();	77	const llvm::Function* func = _functionToCopy->d->data->function();
78	llvm::FunctionType *FTy =	78	llvm::FunctionType *FTy =
79	llvm::cast<llvm::FunctionType>(llvm::cast<llvm::PointerType>(func->getType())->getElementType());	79	llvm::cast<llvm::FunctionType>(llvm::cast<llvm::PointerType>(func->getType())->getElementType());
80	llvm::Function* function = dynamic_cast<llvm::Function*>( _llvmModule->getOrInsertFunction( (const std::string&)_symbolName, FTy) );	80	llvm::Function* function = llvm::dyn_cast<llvm::Function>( _llvmModule->getOrInsertFunction( (const std::string&)_symbolName, FTy) );
81	GTLCore::Function::Data* data = new GTLCore::Function::Data( _functionToCopy->parameters(), _functionToCopy->d->data->minimumParameters() );	81	GTLCore::Function::Data* data = new GTLCore::Function::Data( _functionToCopy->parameters(), _functionToCopy->d->data->minimumParameters() );
82	data->setFunction( function );	82	data->setFunction( function );
83	data->setModule( _module );	83	data->setModule( _module );
Lines 137-143 Link Here
137	}	137	}
138	llvmArguments.push_back( type );	138	llvmArguments.push_back( type );
139	}	139	}
140	llvm::Function* function = dynamic_cast<llvm::Function*>( _llvmModule->getOrInsertFunction( (const std::string&)_symbolName, llvm::FunctionType::get( retType->d->asArgumentType(_context), llvmArguments, false ) ) );	140	llvm::Function* function = llvm::dyn_cast<llvm::Function>( _llvmModule->getOrInsertFunction( (const std::string&)_symbolName, llvm::FunctionType::get( retType->d->asArgumentType(_context), llvmArguments, false ) ) );
141	GTLCore::Function::Data* data = new GTLCore::Function::Data(arguments, minimumParameters == -1 ? arguments.size() : minimumParameters );	141	GTLCore::Function::Data* data = new GTLCore::Function::Data(arguments, minimumParameters == -1 ? arguments.size() : minimumParameters );
142	data->setFunction( function );	142	data->setFunction( function );
143	data->setModule( _module );	143	data->setModule( _module );




  if( constant->getType() == llvm::Type::getInt32Ty(constant->getContext() ) )
  {
    GTL_ASSERT(_type == Type::Integer32 or _type == Type::UnsignedInteger32 );
    return gtl_int32(llvm::dyn_cast<llvm::ConstantInt>( constant )->getValue().getLimitedValue());
  } else if ( constant->getType() == llvm::Type::getFloatTy(constant->getContext()) )
  {
    GTL_ASSERT(_type == Type::Float32 or _type == Type::Float16 );
    return llvm::dyn_cast<llvm::ConstantFP>( constant )->getValueAPF().convertToFloat();
  } else if ( constant->getType() == llvm::Type::getInt1Ty(constant->getContext()) ) {
    GTL_ASSERT(_type == Type::Boolean );
	return llvm::dyn_cast<llvm::ConstantInt>( constant )->getValue().getLimitedValue() != 0;
  } else if( constant->getType()->getTypeID() == llvm::Type::StructTyID ) {
    llvm::ConstantStruct* cs = llvm::dyn_cast<llvm::ConstantStruct>( constant );
    switch(_type->dataType())
    {
      case Type::STRUCTURE:

      {
        GTL_ASSERT( cs->getNumOperands() == 2 + STRUCT_FIRST_ELEMENT );
        GTL_ASSERT( cs->getOperand(1)->getType() == llvm::Type::getInt32Ty(constant->getContext()) );
		std::size_t sizeArray = std::size_t(llvm::dyn_cast<llvm::ConstantInt>( cs->getOperand(1))->getValue().getLimitedValue());
        llvm::ConstantExpr* expr = llvm::dyn_cast<llvm::ConstantExpr>(cs->getOperand(2));
        GTL_ASSERT(expr);
        llvm::GlobalVariable* arrayGV = llvm::dyn_cast<llvm::GlobalVariable>(expr->getOperand(0));
        GTL_ASSERT(arrayGV);
        llvm::ConstantArray* array = llvm::dyn_cast<llvm::ConstantArray>(arrayGV->getInitializer());
        GTL_ASSERT(array);
        GTL_ASSERT(array->getNumOperands() == sizeArray);
        std::vector< Value > values;

        GTL_ABORT("Unsupported type");
    }
  } else if( constant->getType()->getTypeID() == llvm::Type::PointerTyID) {
    return constantToValue( llvm::dyn_cast<llvm::GlobalVariable>(constant)->getInitializer() , _type);
  } else {
    GTL_ABORT("Unimplemented");
  }

llvm::Value* CodeGenerator::convertValueTo(llvm::BasicBlock* _currentBlock, llvm::Value* _value, const Type* _valueType, const Type* _targetType)
{
  GTL_DEBUG("Convert value " << *_value << " from " << *_valueType << " to " << *_targetType);
  llvm::Constant* _constant = llvm::dyn_cast<llvm::Constant>(_value);
  if(_constant)
  {
    return convertConstantTo( _constant, _valueType, _targetType);

{
  std::vector< llvm::Type*> llvmArguments;
  llvmArguments.push_back( llvm::Type::getFloatTy(_generationContext.llvmContext()) );
  llvm::Function* func = llvm::dyn_cast<llvm::Function>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10float2halff",
      llvm::FunctionType::get( llvm::Type::getInt16Ty(_generationContext.llvmContext()) , llvmArguments, false ) ) );
  std::vector<llvm::Value*> convertedParams;
  convertedParams.push_back( convertValueTo( currentBlock, value, _valueType, Type::Float32 ) );

{
  std::vector<llvm::Type*> llvmArguments;
  llvmArguments.push_back( llvm::Type::getInt16Ty(_generationContext.llvmContext()) );
  llvm::Function* func = llvm::dyn_cast<llvm::Function>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10half2floatt",
      llvm::FunctionType::get( llvm::Type::getFloatTy(_generationContext.llvmContext()) , llvmArguments, false ) ) );
  std::vector<llvm::Value*> convertedParams;
  convertedParams.push_back( convertValueTo( currentBlock, value, Type::Float16, Type::Integer16 ) );

{
  GTL_DEBUG(*constant);
  GTL_DEBUG(*constant->getType());
  llvm::ConstantStruct* arrayConstant = llvm::dyn_cast<llvm::ConstantStruct>(constant->getOperand(0));
  GTL_ASSERT(arrayConstant);
  GTL_ASSERT(constantType->dataType() == Type::ARRAY );
  GTL_ASSERT(type->dataType() == Type::VECTOR );
  GTL_ASSERT(arrayConstant->getNumOperands() == 3 );
  llvm::Constant* values = llvm::cast<llvm::Constant>(llvm::cast<llvm::Constant>(arrayConstant->getOperand(2)->getOperand(0))->getOperand(0));
  GTL_DEBUG(*values);
  GTL_ASSERT(llvm::dyn_cast<llvm::ConstantArray>(values) );
  std::vector<llvm::Constant*> constants;
  for(unsigned int i = 0; i < values->getNumOperands(); ++i )
  {

Lines 108-114 Link Here

(-)a/OpenGTL/GTLCore/LLVMBackend/ExpressionResult_p.cpp (-1 / +1 lines)
108		108
109	llvm::Constant* ExpressionResult::constant() const	109	llvm::Constant* ExpressionResult::constant() const
110	{	110	{
111	GTL_ASSERT( dynamic_cast<llvm::Constant*>(d->valueOrConstant.value));	111	GTL_ASSERT( llvm::dyn_cast<llvm::Constant>(d->valueOrConstant.value));
112	if(d->isConstant) return d->valueOrConstant.constant;	112	if(d->isConstant) return d->valueOrConstant.constant;
113	return 0;	113	return 0;
114	}	114	}

Lines 23-29 Link Here

(-)a/OpenGTL/GTLCore/ModuleData_p.cpp (-1 lines)
23		23
24	#include <llvm/Module.h>	24	#include <llvm/Module.h>
25	#include <llvm/PassManager.h>	25	#include <llvm/PassManager.h>
26	#include <llvm/Target/TargetData.h>
27	#include <llvm/Target/TargetMachine.h>	26	#include <llvm/Target/TargetMachine.h>
28	#include <llvm/Analysis/Verifier.h>	27	#include <llvm/Analysis/Verifier.h>
29	#include <llvm/Transforms/Utils/Cloning.h>	28	#include <llvm/Transforms/Utils/Cloning.h>

Return to bug 453420

Lines 209-224 Link Here

(-)a/OpenGTL/GTLCore/LLVMBackend/CodeGenerator_p.cpp (-14 / +14 lines)
209	if( constant->getType() == llvm::Type::getInt32Ty(constant->getContext() ) )	209	if( constant->getType() == llvm::Type::getInt32Ty(constant->getContext() ) )
210	{	210	{
211	GTL_ASSERT(_type == Type::Integer32 or _type == Type::UnsignedInteger32 );	211	GTL_ASSERT(_type == Type::Integer32 or _type == Type::UnsignedInteger32 );
212	return gtl_int32(dynamic_cast<llvm::ConstantInt* >( constant )->getValue().getLimitedValue());	212	return gtl_int32(llvm::dyn_cast<llvm::ConstantInt>( constant )->getValue().getLimitedValue());
213	} else if ( constant->getType() == llvm::Type::getFloatTy(constant->getContext()) )	213	} else if ( constant->getType() == llvm::Type::getFloatTy(constant->getContext()) )
214	{	214	{
215	GTL_ASSERT(_type == Type::Float32 or _type == Type::Float16 );	215	GTL_ASSERT(_type == Type::Float32 or _type == Type::Float16 );
216	return dynamic_cast<llvm::ConstantFP* >( constant )->getValueAPF().convertToFloat();	216	return llvm::dyn_cast<llvm::ConstantFP>( constant )->getValueAPF().convertToFloat();
217	} else if ( constant->getType() == llvm::Type::getInt1Ty(constant->getContext()) ) {	217	} else if ( constant->getType() == llvm::Type::getInt1Ty(constant->getContext()) ) {
218	GTL_ASSERT(_type == Type::Boolean );	218	GTL_ASSERT(_type == Type::Boolean );
219	return dynamic_cast<llvm::ConstantInt* >( constant )->getValue().getLimitedValue() != 0;	219	return llvm::dyn_cast<llvm::ConstantInt>( constant )->getValue().getLimitedValue() != 0;
220	} else if( constant->getType()->getTypeID() == llvm::Type::StructTyID ) {	220	} else if( constant->getType()->getTypeID() == llvm::Type::StructTyID ) {
221	llvm::ConstantStruct* cs = dynamic_cast<llvm::ConstantStruct* >( constant );	221	llvm::ConstantStruct* cs = llvm::dyn_cast<llvm::ConstantStruct>( constant );
222	switch(_type->dataType())	222	switch(_type->dataType())
223	{	223	{
224	case Type::STRUCTURE:	224	case Type::STRUCTURE:
Lines 235-246 Link Here
235	{	235	{
236	GTL_ASSERT( cs->getNumOperands() == 2 + STRUCT_FIRST_ELEMENT );	236	GTL_ASSERT( cs->getNumOperands() == 2 + STRUCT_FIRST_ELEMENT );
237	GTL_ASSERT( cs->getOperand(1)->getType() == llvm::Type::getInt32Ty(constant->getContext()) );	237	GTL_ASSERT( cs->getOperand(1)->getType() == llvm::Type::getInt32Ty(constant->getContext()) );
238	std::size_t sizeArray = std::size_t(dynamic_cast<llvm::ConstantInt* >( cs->getOperand(1))->getValue().getLimitedValue());	238	std::size_t sizeArray = std::size_t(llvm::dyn_cast<llvm::ConstantInt>( cs->getOperand(1))->getValue().getLimitedValue());
239	llvm::ConstantExpr* expr = dynamic_cast<llvm::ConstantExpr*>(cs->getOperand(2));	239	llvm::ConstantExpr* expr = llvm::dyn_cast<llvm::ConstantExpr>(cs->getOperand(2));
240	GTL_ASSERT(expr);	240	GTL_ASSERT(expr);
241	llvm::GlobalVariable* arrayGV = dynamic_cast<llvm::GlobalVariable*>(expr->getOperand(0));	241	llvm::GlobalVariable* arrayGV = llvm::dyn_cast<llvm::GlobalVariable>(expr->getOperand(0));
242	GTL_ASSERT(arrayGV);	242	GTL_ASSERT(arrayGV);
243	llvm::ConstantArray* array = dynamic_cast<llvm::ConstantArray*>(arrayGV->getInitializer());	243	llvm::ConstantArray* array = llvm::dyn_cast<llvm::ConstantArray>(arrayGV->getInitializer());
244	GTL_ASSERT(array);	244	GTL_ASSERT(array);
245	GTL_ASSERT(array->getNumOperands() == sizeArray);	245	GTL_ASSERT(array->getNumOperands() == sizeArray);
246	std::vector< Value > values;	246	std::vector< Value > values;
Lines 254-260 Link Here
254	GTL_ABORT("Unsupported type");	254	GTL_ABORT("Unsupported type");
255	}	255	}
256	} else if( constant->getType()->getTypeID() == llvm::Type::PointerTyID) {	256	} else if( constant->getType()->getTypeID() == llvm::Type::PointerTyID) {
257	return constantToValue( dynamic_cast<llvm::GlobalVariable*>(constant)->getInitializer() , _type);	257	return constantToValue( llvm::dyn_cast<llvm::GlobalVariable>(constant)->getInitializer() , _type);
258	} else {	258	} else {
259	GTL_ABORT("Unimplemented");	259	GTL_ABORT("Unimplemented");
260	}	260	}
Lines 316-322 Link Here
316	llvm::Value* CodeGenerator::convertValueTo(llvm::BasicBlock* _currentBlock, llvm::Value* _value, const Type* _valueType, const Type* _targetType)	316	llvm::Value* CodeGenerator::convertValueTo(llvm::BasicBlock* _currentBlock, llvm::Value* _value, const Type* _valueType, const Type* _targetType)
317	{	317	{
318	GTL_DEBUG("Convert value " << _value << " from " << _valueType << " to " << *_targetType);	318	GTL_DEBUG("Convert value " << _value << " from " << _valueType << " to " << *_targetType);
319	llvm::Constant* _constant = dynamic_cast<llvm::Constant*>(_value);	319	llvm::Constant* _constant = llvm::dyn_cast<llvm::Constant>(_value);
320	if(_constant)	320	if(_constant)
321	{	321	{
322	return convertConstantTo( _constant, _valueType, _targetType);	322	return convertConstantTo( _constant, _valueType, _targetType);
Lines 386-392 Link Here
386	{	386	{
387	std::vector< llvm::Type*> llvmArguments;	387	std::vector< llvm::Type*> llvmArguments;
388	llvmArguments.push_back( llvm::Type::getFloatTy(_generationContext.llvmContext()) );	388	llvmArguments.push_back( llvm::Type::getFloatTy(_generationContext.llvmContext()) );
389	llvm::Function* func = dynamic_cast<llvm::Function*>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10float2halff",	389	llvm::Function* func = llvm::dyn_cast<llvm::Function>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10float2halff",
390	llvm::FunctionType::get( llvm::Type::getInt16Ty(_generationContext.llvmContext()) , llvmArguments, false ) ) );	390	llvm::FunctionType::get( llvm::Type::getInt16Ty(_generationContext.llvmContext()) , llvmArguments, false ) ) );
391	std::vector<llvm::Value*> convertedParams;	391	std::vector<llvm::Value*> convertedParams;
392	convertedParams.push_back( convertValueTo( currentBlock, value, _valueType, Type::Float32 ) );	392	convertedParams.push_back( convertValueTo( currentBlock, value, _valueType, Type::Float32 ) );
Lines 397-403 Link Here
397	{	397	{
398	std::vector<llvm::Type*> llvmArguments;	398	std::vector<llvm::Type*> llvmArguments;
399	llvmArguments.push_back( llvm::Type::getInt16Ty(_generationContext.llvmContext()) );	399	llvmArguments.push_back( llvm::Type::getInt16Ty(_generationContext.llvmContext()) );
400	llvm::Function* func = dynamic_cast<llvm::Function*>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10half2floatt",	400	llvm::Function* func = llvm::dyn_cast<llvm::Function>( _generationContext.llvmModule()->getOrInsertFunction( "_Z10half2floatt",
401	llvm::FunctionType::get( llvm::Type::getFloatTy(_generationContext.llvmContext()) , llvmArguments, false ) ) );	401	llvm::FunctionType::get( llvm::Type::getFloatTy(_generationContext.llvmContext()) , llvmArguments, false ) ) );
402	std::vector<llvm::Value*> convertedParams;	402	std::vector<llvm::Value*> convertedParams;
403	convertedParams.push_back( convertValueTo( currentBlock, value, Type::Float16, Type::Integer16 ) );	403	convertedParams.push_back( convertValueTo( currentBlock, value, Type::Float16, Type::Integer16 ) );
Lines 461-474 Link Here
461	{	461	{
462	GTL_DEBUG(*constant);	462	GTL_DEBUG(*constant);
463	GTL_DEBUG(*constant->getType());	463	GTL_DEBUG(*constant->getType());
464	llvm::ConstantStruct* arrayConstant = dynamic_cast<llvm::ConstantStruct*>(constant->getOperand(0));	464	llvm::ConstantStruct* arrayConstant = llvm::dyn_cast<llvm::ConstantStruct>(constant->getOperand(0));
465	GTL_ASSERT(arrayConstant);	465	GTL_ASSERT(arrayConstant);
466	GTL_ASSERT(constantType->dataType() == Type::ARRAY );	466	GTL_ASSERT(constantType->dataType() == Type::ARRAY );
467	GTL_ASSERT(type->dataType() == Type::VECTOR );	467	GTL_ASSERT(type->dataType() == Type::VECTOR );
468	GTL_ASSERT(arrayConstant->getNumOperands() == 3 );	468	GTL_ASSERT(arrayConstant->getNumOperands() == 3 );
469	llvm::Constant* values = llvm::cast<llvm::Constant>(llvm::cast<llvm::Constant>(arrayConstant->getOperand(2)->getOperand(0))->getOperand(0));	469	llvm::Constant* values = llvm::cast<llvm::Constant>(llvm::cast<llvm::Constant>(arrayConstant->getOperand(2)->getOperand(0))->getOperand(0));
470	GTL_DEBUG(*values);	470	GTL_DEBUG(*values);
471	GTL_ASSERT(dynamic_cast<llvm::ConstantArray*>(values) );	471	GTL_ASSERT(llvm::dyn_cast<llvm::ConstantArray>(values) );
472	std::vector<llvm::Constant*> constants;	472	std::vector<llvm::Constant*> constants;
473	for(unsigned int i = 0; i < values->getNumOperands(); ++i )	473	for(unsigned int i = 0; i < values->getNumOperands(); ++i )
474	{	474	{

Lines 25-35 Link Here

(-)a/OpenGTL/GTLCore/Debug.cpp (-5 / +6 lines)
25	#include <llvm/Module.h>	25	#include <llvm/Module.h>
26	#include <llvm/Value.h>	26	#include <llvm/Value.h>
27	#include <llvm/Type.h>	27	#include <llvm/Type.h>
28	#ifdef LLVM_27_OR_28
29	#include <llvm/System/Path.h>
30	#else
31	#include <llvm/Support/Path.h>	28	#include <llvm/Support/Path.h>
32	#endif
33	#include <llvm/Support/raw_ostream.h>	29	#include <llvm/Support/raw_ostream.h>
34		30
35	#include "Function.h"	31	#include "Function.h"
Lines 450-461 Link Here
450	#endif	446	#endif
451		447
452	namespace llvm {	448	namespace llvm {
		449	// Printing of types.
		450	static inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
		451	T.print(OS);
		452	return OS;
		453	}
453	#define MAKE_OPERATOR(_type_) \	454	#define MAKE_OPERATOR(_type_) \
454	std::ostream& operator<< (std::ostream& ostr, const llvm::_type_& val) \	455	std::ostream& operator<< (std::ostream& ostr, const llvm::_type_& val) \
455	{ \	456	{ \
456	std::string str; \	457	std::string str; \
457	llvm::raw_string_ostream rs(str); \	458	llvm::raw_string_ostream rs(str); \
458	rs << &val; \	459	rs << val; \
459	rs.flush(); \	460	rs.flush(); \
460	ostr << str; \	461	ostr << str; \
461	return ostr; \	462	return ostr; \