//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This library implements the functionality defined in llvm/IR/Writer.h // // Note that these routines must be extremely tolerant of various errors in the // LLVM code, because it can be used for debugging transformations. // //===----------------------------------------------------------------------===// #include "AsmWriter.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/DebugInfo.h" #include "llvm/IR/AssemblyAnnotationWriter.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/IRPrintingPasses.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IR/Operator.h" #include "llvm/IR/TypeFinder.h" #include "llvm/IR/ValueSymbolTable.h" #include "llvm/Support/CFG.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Dwarf.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Support/MathExtras.h" #include #include using namespace llvm; // Make virtual table appear in this compilation unit. AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} //===----------------------------------------------------------------------===// // Helper Functions //===----------------------------------------------------------------------===// static const Module *getModuleFromVal(const Value *V) { if (const Argument *MA = dyn_cast(V)) return MA->getParent() ? MA->getParent()->getParent() : 0; if (const BasicBlock *BB = dyn_cast(V)) return BB->getParent() ? BB->getParent()->getParent() : 0; if (const Instruction *I = dyn_cast(V)) { const Function *M = I->getParent() ? I->getParent()->getParent() : 0; return M ? M->getParent() : 0; } if (const GlobalValue *GV = dyn_cast(V)) return GV->getParent(); return 0; } static void PrintCallingConv(unsigned cc, raw_ostream &Out) { switch (cc) { default: Out << "cc" << cc; break; case CallingConv::Fast: Out << "fastcc"; break; case CallingConv::Cold: Out << "coldcc"; break; case CallingConv::WebKit_JS: Out << "webkit_jscc"; break; case CallingConv::AnyReg: Out << "anyregcc"; break; case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break; case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break; case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break; case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break; case CallingConv::ARM_APCS: Out << "arm_apcscc"; break; case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break; case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break; case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break; case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break; case CallingConv::PTX_Device: Out << "ptx_device"; break; case CallingConv::X86_64_SysV: Out << "x86_64_sysvcc"; break; case CallingConv::X86_64_Win64: Out << "x86_64_win64cc"; break; case CallingConv::SPIR_FUNC: Out << "spir_func"; break; case CallingConv::SPIR_KERNEL: Out << "spir_kernel"; break; } } // PrintEscapedString - Print each character of the specified string, escaping // it if it is not printable or if it is an escape char. static void PrintEscapedString(StringRef Name, raw_ostream &Out) { for (unsigned i = 0, e = Name.size(); i != e; ++i) { unsigned char C = Name[i]; if (isprint(C) && C != '\\' && C != '"') Out << C; else Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F); } } enum PrefixType { GlobalPrefix, LabelPrefix, LocalPrefix, NoPrefix }; /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either /// prefixed with % (if the string only contains simple characters) or is /// surrounded with ""'s (if it has special chars in it). Print it out. static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) { assert(!Name.empty() && "Cannot get empty name!"); switch (Prefix) { case NoPrefix: break; case GlobalPrefix: OS << '@'; break; case LabelPrefix: break; case LocalPrefix: OS << '%'; break; } // Scan the name to see if it needs quotes first. bool NeedsQuotes = isdigit(static_cast(Name[0])); if (!NeedsQuotes) { for (unsigned i = 0, e = Name.size(); i != e; ++i) { // By making this unsigned, the value passed in to isalnum will always be // in the range 0-255. This is important when building with MSVC because // its implementation will assert. This situation can arise when dealing // with UTF-8 multibyte characters. unsigned char C = Name[i]; if (!isalnum(static_cast(C)) && C != '-' && C != '.' && C != '_') { NeedsQuotes = true; break; } } } // If we didn't need any quotes, just write out the name in one blast. if (!NeedsQuotes) { OS << Name; return; } // Okay, we need quotes. Output the quotes and escape any scary characters as // needed. OS << '"'; PrintEscapedString(Name, OS); OS << '"'; } /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either /// prefixed with % (if the string only contains simple characters) or is /// surrounded with ""'s (if it has special chars in it). Print it out. static void PrintLLVMName(raw_ostream &OS, const Value *V) { PrintLLVMName(OS, V->getName(), isa(V) ? GlobalPrefix : LocalPrefix); } namespace llvm { void TypePrinting::incorporateTypes(const Module &M) { NamedTypes.run(M, false); // The list of struct types we got back includes all the struct types, split // the unnamed ones out to a numbering and remove the anonymous structs. unsigned NextNumber = 0; std::vector::iterator NextToUse = NamedTypes.begin(), I, E; for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) { StructType *STy = *I; // Ignore anonymous types. if (STy->isLiteral()) continue; if (STy->getName().empty()) NumberedTypes[STy] = NextNumber++; else *NextToUse++ = STy; } NamedTypes.erase(NextToUse, NamedTypes.end()); } /// CalcTypeName - Write the specified type to the specified raw_ostream, making /// use of type names or up references to shorten the type name where possible. void TypePrinting::print(Type *Ty, raw_ostream &OS) { switch (Ty->getTypeID()) { case Type::VoidTyID: OS << "void"; return; case Type::HalfTyID: OS << "half"; return; case Type::FloatTyID: OS << "float"; return; case Type::DoubleTyID: OS << "double"; return; case Type::X86_FP80TyID: OS << "x86_fp80"; return; case Type::FP128TyID: OS << "fp128"; return; case Type::PPC_FP128TyID: OS << "ppc_fp128"; return; case Type::LabelTyID: OS << "label"; return; case Type::MetadataTyID: OS << "metadata"; return; case Type::X86_MMXTyID: OS << "x86_mmx"; return; case Type::IntegerTyID: OS << 'i' << cast(Ty)->getBitWidth(); return; case Type::FunctionTyID: { FunctionType *FTy = cast(Ty); print(FTy->getReturnType(), OS); OS << " ("; for (FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); I != E; ++I) { if (I != FTy->param_begin()) OS << ", "; print(*I, OS); } if (FTy->isVarArg()) { if (FTy->getNumParams()) OS << ", "; OS << "..."; } OS << ')'; return; } case Type::StructTyID: { StructType *STy = cast(Ty); if (STy->isLiteral()) return printStructBody(STy, OS); if (!STy->getName().empty()) return PrintLLVMName(OS, STy->getName(), LocalPrefix); DenseMap::iterator I = NumberedTypes.find(STy); if (I != NumberedTypes.end()) OS << '%' << I->second; else // Not enumerated, print the hex address. OS << "%\"type " << STy << '\"'; return; } case Type::PointerTyID: { PointerType *PTy = cast(Ty); print(PTy->getElementType(), OS); if (unsigned AddressSpace = PTy->getAddressSpace()) OS << " addrspace(" << AddressSpace << ')'; OS << '*'; return; } case Type::ArrayTyID: { ArrayType *ATy = cast(Ty); OS << '[' << ATy->getNumElements() << " x "; print(ATy->getElementType(), OS); OS << ']'; return; } case Type::VectorTyID: { VectorType *PTy = cast(Ty); OS << "<" << PTy->getNumElements() << " x "; print(PTy->getElementType(), OS); OS << '>'; return; } } llvm_unreachable("Invalid TypeID"); } void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) { if (STy->isOpaque()) { OS << "opaque"; return; } if (STy->isPacked()) OS << '<'; if (STy->getNumElements() == 0) { OS << "{}"; } else { StructType::element_iterator I = STy->element_begin(); OS << "{ "; print(*I++, OS); for (StructType::element_iterator E = STy->element_end(); I != E; ++I) { OS << ", "; print(*I, OS); } OS << " }"; } if (STy->isPacked()) OS << '>'; } //===----------------------------------------------------------------------===// // SlotTracker Class: Enumerate slot numbers for unnamed values //===----------------------------------------------------------------------===// /// This class provides computation of slot numbers for LLVM Assembly writing. /// class SlotTracker { public: /// ValueMap - A mapping of Values to slot numbers. typedef DenseMap ValueMap; private: /// TheModule - The module for which we are holding slot numbers. const Module* TheModule; /// TheFunction - The function for which we are holding slot numbers. const Function* TheFunction; bool FunctionProcessed; /// mMap - The slot map for the module level data. ValueMap mMap; unsigned mNext; /// fMap - The slot map for the function level data. ValueMap fMap; unsigned fNext; /// mdnMap - Map for MDNodes. DenseMap mdnMap; unsigned mdnNext; /// asMap - The slot map for attribute sets. DenseMap asMap; unsigned asNext; public: /// Construct from a module explicit SlotTracker(const Module *M); /// Construct from a function, starting out in incorp state. explicit SlotTracker(const Function *F); /// Return the slot number of the specified value in it's type /// plane. If something is not in the SlotTracker, return -1. int getLocalSlot(const Value *V); int getGlobalSlot(const GlobalValue *V); int getMetadataSlot(const MDNode *N); int getAttributeGroupSlot(AttributeSet AS); /// If you'd like to deal with a function instead of just a module, use /// this method to get its data into the SlotTracker. void incorporateFunction(const Function *F) { TheFunction = F; FunctionProcessed = false; } /// After calling incorporateFunction, use this method to remove the /// most recently incorporated function from the SlotTracker. This /// will reset the state of the machine back to just the module contents. void purgeFunction(); /// MDNode map iterators. typedef DenseMap::iterator mdn_iterator; mdn_iterator mdn_begin() { return mdnMap.begin(); } mdn_iterator mdn_end() { return mdnMap.end(); } unsigned mdn_size() const { return mdnMap.size(); } bool mdn_empty() const { return mdnMap.empty(); } /// AttributeSet map iterators. typedef DenseMap::iterator as_iterator; as_iterator as_begin() { return asMap.begin(); } as_iterator as_end() { return asMap.end(); } unsigned as_size() const { return asMap.size(); } bool as_empty() const { return asMap.empty(); } /// This function does the actual initialization. inline void initialize(); // Implementation Details private: /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. void CreateModuleSlot(const GlobalValue *V); /// CreateMetadataSlot - Insert the specified MDNode* into the slot table. void CreateMetadataSlot(const MDNode *N); /// CreateFunctionSlot - Insert the specified Value* into the slot table. void CreateFunctionSlot(const Value *V); /// \brief Insert the specified AttributeSet into the slot table. void CreateAttributeSetSlot(AttributeSet AS); /// Add all of the module level global variables (and their initializers) /// and function declarations, but not the contents of those functions. void processModule(); /// Add all of the functions arguments, basic blocks, and instructions. void processFunction(); SlotTracker(const SlotTracker &) LLVM_DELETED_FUNCTION; void operator=(const SlotTracker &) LLVM_DELETED_FUNCTION; }; SlotTracker *createSlotTracker(const Module *M) { return new SlotTracker(M); } static SlotTracker *createSlotTracker(const Value *V) { if (const Argument *FA = dyn_cast(V)) return new SlotTracker(FA->getParent()); if (const Instruction *I = dyn_cast(V)) if (I->getParent()) return new SlotTracker(I->getParent()->getParent()); if (const BasicBlock *BB = dyn_cast(V)) return new SlotTracker(BB->getParent()); if (const GlobalVariable *GV = dyn_cast(V)) return new SlotTracker(GV->getParent()); if (const GlobalAlias *GA = dyn_cast(V)) return new SlotTracker(GA->getParent()); if (const Function *Func = dyn_cast(V)) return new SlotTracker(Func); if (const MDNode *MD = dyn_cast(V)) { if (!MD->isFunctionLocal()) return new SlotTracker(MD->getFunction()); return new SlotTracker((Function *)0); } return 0; } #if 0 #define ST_DEBUG(X) dbgs() << X #else #define ST_DEBUG(X) #endif // Module level constructor. Causes the contents of the Module (sans functions) // to be added to the slot table. SlotTracker::SlotTracker(const Module *M) : TheModule(M), TheFunction(0), FunctionProcessed(false), mNext(0), fNext(0), mdnNext(0), asNext(0) { } // Function level constructor. Causes the contents of the Module and the one // function provided to be added to the slot table. SlotTracker::SlotTracker(const Function *F) : TheModule(F ? F->getParent() : 0), TheFunction(F), FunctionProcessed(false), mNext(0), fNext(0), mdnNext(0), asNext(0) { } inline void SlotTracker::initialize() { if (TheModule) { processModule(); TheModule = 0; ///< Prevent re-processing next time we're called. } if (TheFunction && !FunctionProcessed) processFunction(); } // Iterate through all the global variables, functions, and global // variable initializers and create slots for them. void SlotTracker::processModule() { ST_DEBUG("begin processModule!\n"); // Add all of the unnamed global variables to the value table. for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end(); I != E; ++I) { if (!I->hasName()) CreateModuleSlot(I); } // Add metadata used by named metadata. for (Module::const_named_metadata_iterator I = TheModule->named_metadata_begin(), E = TheModule->named_metadata_end(); I != E; ++I) { const NamedMDNode *NMD = I; for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) CreateMetadataSlot(NMD->getOperand(i)); } for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); I != E; ++I) { if (!I->hasName()) // Add all the unnamed functions to the table. CreateModuleSlot(I); // Add all the function attributes to the table. // FIXME: Add attributes of other objects? AttributeSet FnAttrs = I->getAttributes().getFnAttributes(); if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex)) CreateAttributeSetSlot(FnAttrs); } ST_DEBUG("end processModule!\n"); } // Process the arguments, basic blocks, and instructions of a function. void SlotTracker::processFunction() { ST_DEBUG("begin processFunction!\n"); fNext = 0; // Add all the function arguments with no names. for(Function::const_arg_iterator AI = TheFunction->arg_begin(), AE = TheFunction->arg_end(); AI != AE; ++AI) if (!AI->hasName()) CreateFunctionSlot(AI); ST_DEBUG("Inserting Instructions:\n"); SmallVector, 4> MDForInst; // Add all of the basic blocks and instructions with no names. for (Function::const_iterator BB = TheFunction->begin(), E = TheFunction->end(); BB != E; ++BB) { if (!BB->hasName()) CreateFunctionSlot(BB); for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { if (!I->getType()->isVoidTy() && !I->hasName()) CreateFunctionSlot(I); // Intrinsics can directly use metadata. We allow direct calls to any // llvm.foo function here, because the target may not be linked into the // optimizer. if (const CallInst *CI = dyn_cast(I)) { if (Function *F = CI->getCalledFunction()) if (F->isIntrinsic()) for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) if (MDNode *N = dyn_cast_or_null(I->getOperand(i))) CreateMetadataSlot(N); // Add all the call attributes to the table. AttributeSet Attrs = CI->getAttributes().getFnAttributes(); if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) CreateAttributeSetSlot(Attrs); } else if (const InvokeInst *II = dyn_cast(I)) { // Add all the call attributes to the table. AttributeSet Attrs = II->getAttributes().getFnAttributes(); if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) CreateAttributeSetSlot(Attrs); } // Process metadata attached with this instruction. I->getAllMetadata(MDForInst); for (unsigned i = 0, e = MDForInst.size(); i != e; ++i) CreateMetadataSlot(MDForInst[i].second); MDForInst.clear(); } } FunctionProcessed = true; ST_DEBUG("end processFunction!\n"); } /// Clean up after incorporating a function. This is the only way to get out of /// the function incorporation state that affects get*Slot/Create*Slot. Function /// incorporation state is indicated by TheFunction != 0. void SlotTracker::purgeFunction() { ST_DEBUG("begin purgeFunction!\n"); fMap.clear(); // Simply discard the function level map TheFunction = 0; FunctionProcessed = false; ST_DEBUG("end purgeFunction!\n"); } /// getGlobalSlot - Get the slot number of a global value. int SlotTracker::getGlobalSlot(const GlobalValue *V) { // Check for uninitialized state and do lazy initialization. initialize(); // Find the value in the module map ValueMap::iterator MI = mMap.find(V); return MI == mMap.end() ? -1 : (int)MI->second; } /// getMetadataSlot - Get the slot number of a MDNode. int SlotTracker::getMetadataSlot(const MDNode *N) { // Check for uninitialized state and do lazy initialization. initialize(); // Find the MDNode in the module map mdn_iterator MI = mdnMap.find(N); return MI == mdnMap.end() ? -1 : (int)MI->second; } /// getLocalSlot - Get the slot number for a value that is local to a function. int SlotTracker::getLocalSlot(const Value *V) { assert(!isa(V) && "Can't get a constant or global slot with this!"); // Check for uninitialized state and do lazy initialization. initialize(); ValueMap::iterator FI = fMap.find(V); return FI == fMap.end() ? -1 : (int)FI->second; } int SlotTracker::getAttributeGroupSlot(AttributeSet AS) { // Check for uninitialized state and do lazy initialization. initialize(); // Find the AttributeSet in the module map. as_iterator AI = asMap.find(AS); return AI == asMap.end() ? -1 : (int)AI->second; } /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. void SlotTracker::CreateModuleSlot(const GlobalValue *V) { assert(V && "Can't insert a null Value into SlotTracker!"); assert(!V->getType()->isVoidTy() && "Doesn't need a slot!"); assert(!V->hasName() && "Doesn't need a slot!"); unsigned DestSlot = mNext++; mMap[V] = DestSlot; ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << DestSlot << " ["); // G = Global, F = Function, A = Alias, o = other ST_DEBUG((isa(V) ? 'G' : (isa(V) ? 'F' : (isa(V) ? 'A' : 'o'))) << "]\n"); } /// CreateSlot - Create a new slot for the specified value if it has no name. void SlotTracker::CreateFunctionSlot(const Value *V) { assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!"); unsigned DestSlot = fNext++; fMap[V] = DestSlot; // G = Global, F = Function, o = other ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << DestSlot << " [o]\n"); } /// CreateModuleSlot - Insert the specified MDNode* into the slot table. void SlotTracker::CreateMetadataSlot(const MDNode *N) { assert(N && "Can't insert a null Value into SlotTracker!"); // Don't insert if N is a function-local metadata, these are always printed // inline. if (!N->isFunctionLocal()) { mdn_iterator I = mdnMap.find(N); if (I != mdnMap.end()) return; unsigned DestSlot = mdnNext++; mdnMap[N] = DestSlot; } // Recursively add any MDNodes referenced by operands. for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) if (const MDNode *Op = dyn_cast_or_null(N->getOperand(i))) CreateMetadataSlot(Op); } void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) { assert(AS.hasAttributes(AttributeSet::FunctionIndex) && "Doesn't need a slot!"); as_iterator I = asMap.find(AS); if (I != asMap.end()) return; unsigned DestSlot = asNext++; asMap[AS] = DestSlot; } //===----------------------------------------------------------------------===// // AsmWriter Implementation //===----------------------------------------------------------------------===// static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context); static const char *getPredicateText(unsigned predicate) { const char * pred = "unknown"; switch (predicate) { case FCmpInst::FCMP_FALSE: pred = "false"; break; case FCmpInst::FCMP_OEQ: pred = "oeq"; break; case FCmpInst::FCMP_OGT: pred = "ogt"; break; case FCmpInst::FCMP_OGE: pred = "oge"; break; case FCmpInst::FCMP_OLT: pred = "olt"; break; case FCmpInst::FCMP_OLE: pred = "ole"; break; case FCmpInst::FCMP_ONE: pred = "one"; break; case FCmpInst::FCMP_ORD: pred = "ord"; break; case FCmpInst::FCMP_UNO: pred = "uno"; break; case FCmpInst::FCMP_UEQ: pred = "ueq"; break; case FCmpInst::FCMP_UGT: pred = "ugt"; break; case FCmpInst::FCMP_UGE: pred = "uge"; break; case FCmpInst::FCMP_ULT: pred = "ult"; break; case FCmpInst::FCMP_ULE: pred = "ule"; break; case FCmpInst::FCMP_UNE: pred = "une"; break; case FCmpInst::FCMP_TRUE: pred = "true"; break; case ICmpInst::ICMP_EQ: pred = "eq"; break; case ICmpInst::ICMP_NE: pred = "ne"; break; case ICmpInst::ICMP_SGT: pred = "sgt"; break; case ICmpInst::ICMP_SGE: pred = "sge"; break; case ICmpInst::ICMP_SLT: pred = "slt"; break; case ICmpInst::ICMP_SLE: pred = "sle"; break; case ICmpInst::ICMP_UGT: pred = "ugt"; break; case ICmpInst::ICMP_UGE: pred = "uge"; break; case ICmpInst::ICMP_ULT: pred = "ult"; break; case ICmpInst::ICMP_ULE: pred = "ule"; break; } return pred; } static void writeAtomicRMWOperation(raw_ostream &Out, AtomicRMWInst::BinOp Op) { switch (Op) { default: Out << " "; break; case AtomicRMWInst::Xchg: Out << " xchg"; break; case AtomicRMWInst::Add: Out << " add"; break; case AtomicRMWInst::Sub: Out << " sub"; break; case AtomicRMWInst::And: Out << " and"; break; case AtomicRMWInst::Nand: Out << " nand"; break; case AtomicRMWInst::Or: Out << " or"; break; case AtomicRMWInst::Xor: Out << " xor"; break; case AtomicRMWInst::Max: Out << " max"; break; case AtomicRMWInst::Min: Out << " min"; break; case AtomicRMWInst::UMax: Out << " umax"; break; case AtomicRMWInst::UMin: Out << " umin"; break; } } static void WriteOptimizationInfo(raw_ostream &Out, const User *U) { if (const FPMathOperator *FPO = dyn_cast(U)) { // Unsafe algebra implies all the others, no need to write them all out if (FPO->hasUnsafeAlgebra()) Out << " fast"; else { if (FPO->hasNoNaNs()) Out << " nnan"; if (FPO->hasNoInfs()) Out << " ninf"; if (FPO->hasNoSignedZeros()) Out << " nsz"; if (FPO->hasAllowReciprocal()) Out << " arcp"; } } if (const OverflowingBinaryOperator *OBO = dyn_cast(U)) { if (OBO->hasNoUnsignedWrap()) Out << " nuw"; if (OBO->hasNoSignedWrap()) Out << " nsw"; } else if (const PossiblyExactOperator *Div = dyn_cast(U)) { if (Div->isExact()) Out << " exact"; } else if (const GEPOperator *GEP = dyn_cast(U)) { if (GEP->isInBounds()) Out << " inbounds"; } } static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, TypePrinting &TypePrinter, SlotTracker *Machine, const Module *Context) { if (const ConstantInt *CI = dyn_cast(CV)) { if (CI->getType()->isIntegerTy(1)) { Out << (CI->getZExtValue() ? "true" : "false"); return; } Out << CI->getValue(); return; } if (const ConstantFP *CFP = dyn_cast(CV)) { if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle || &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble) { // We would like to output the FP constant value in exponential notation, // but we cannot do this if doing so will lose precision. Check here to // make sure that we only output it in exponential format if we can parse // the value back and get the same value. // bool ignored; bool isHalf = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEhalf; bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble; bool isInf = CFP->getValueAPF().isInfinity(); bool isNaN = CFP->getValueAPF().isNaN(); if (!isHalf && !isInf && !isNaN) { double Val = isDouble ? CFP->getValueAPF().convertToDouble() : CFP->getValueAPF().convertToFloat(); SmallString<128> StrVal; raw_svector_ostream(StrVal) << Val; // Check to make sure that the stringized number is not some string like // "Inf" or NaN, that atof will accept, but the lexer will not. Check // that the string matches the "[-+]?[0-9]" regex. // if ((StrVal[0] >= '0' && StrVal[0] <= '9') || ((StrVal[0] == '-' || StrVal[0] == '+') && (StrVal[1] >= '0' && StrVal[1] <= '9'))) { // Reparse stringized version! if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) { Out << StrVal.str(); return; } } } // Otherwise we could not reparse it to exactly the same value, so we must // output the string in hexadecimal format! Note that loading and storing // floating point types changes the bits of NaNs on some hosts, notably // x86, so we must not use these types. assert(sizeof(double) == sizeof(uint64_t) && "assuming that double is 64 bits!"); char Buffer[40]; APFloat apf = CFP->getValueAPF(); // Halves and floats are represented in ASCII IR as double, convert. if (!isDouble) apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &ignored); Out << "0x" << utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()), Buffer+40); return; } // Either half, or some form of long double. // These appear as a magic letter identifying the type, then a // fixed number of hex digits. Out << "0x"; // Bit position, in the current word, of the next nibble to print. int shiftcount; if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) { Out << 'K'; // api needed to prevent premature destruction APInt api = CFP->getValueAPF().bitcastToAPInt(); const uint64_t* p = api.getRawData(); uint64_t word = p[1]; shiftcount = 12; int width = api.getBitWidth(); for (int j=0; j>shiftcount) & 15; if (nibble < 10) Out << (unsigned char)(nibble + '0'); else Out << (unsigned char)(nibble - 10 + 'A'); if (shiftcount == 0 && j+4 < width) { word = *p; shiftcount = 64; if (width-j-4 < 64) shiftcount = width-j-4; } } return; } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) { shiftcount = 60; Out << 'L'; } else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) { shiftcount = 60; Out << 'M'; } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEhalf) { shiftcount = 12; Out << 'H'; } else llvm_unreachable("Unsupported floating point type"); // api needed to prevent premature destruction APInt api = CFP->getValueAPF().bitcastToAPInt(); const uint64_t* p = api.getRawData(); uint64_t word = *p; int width = api.getBitWidth(); for (int j=0; j>shiftcount) & 15; if (nibble < 10) Out << (unsigned char)(nibble + '0'); else Out << (unsigned char)(nibble - 10 + 'A'); if (shiftcount == 0 && j+4 < width) { word = *(++p); shiftcount = 64; if (width-j-4 < 64) shiftcount = width-j-4; } } return; } if (isa(CV)) { Out << "zeroinitializer"; return; } if (const BlockAddress *BA = dyn_cast(CV)) { Out << "blockaddress("; WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine, Context); Out << ", "; WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine, Context); Out << ")"; return; } if (const ConstantArray *CA = dyn_cast(CV)) { Type *ETy = CA->getType()->getElementType(); Out << '['; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CA->getOperand(0), &TypePrinter, Machine, Context); for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { Out << ", "; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine, Context); } Out << ']'; return; } if (const ConstantDataArray *CA = dyn_cast(CV)) { // As a special case, print the array as a string if it is an array of // i8 with ConstantInt values. if (CA->isString()) { Out << "c\""; PrintEscapedString(CA->getAsString(), Out); Out << '"'; return; } Type *ETy = CA->getType()->getElementType(); Out << '['; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CA->getElementAsConstant(0), &TypePrinter, Machine, Context); for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) { Out << ", "; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter, Machine, Context); } Out << ']'; return; } if (const ConstantStruct *CS = dyn_cast(CV)) { if (CS->getType()->isPacked()) Out << '<'; Out << '{'; unsigned N = CS->getNumOperands(); if (N) { Out << ' '; TypePrinter.print(CS->getOperand(0)->getType(), Out); Out << ' '; WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine, Context); for (unsigned i = 1; i < N; i++) { Out << ", "; TypePrinter.print(CS->getOperand(i)->getType(), Out); Out << ' '; WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine, Context); } Out << ' '; } Out << '}'; if (CS->getType()->isPacked()) Out << '>'; return; } if (isa(CV) || isa(CV)) { Type *ETy = CV->getType()->getVectorElementType(); Out << '<'; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter, Machine, Context); for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){ Out << ", "; TypePrinter.print(ETy, Out); Out << ' '; WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter, Machine, Context); } Out << '>'; return; } if (isa(CV)) { Out << "null"; return; } if (isa(CV)) { Out << "undef"; return; } if (const ConstantExpr *CE = dyn_cast(CV)) { Out << CE->getOpcodeName(); WriteOptimizationInfo(Out, CE); if (CE->isCompare()) Out << ' ' << getPredicateText(CE->getPredicate()); Out << " ("; for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { TypePrinter.print((*OI)->getType(), Out); Out << ' '; WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context); if (OI+1 != CE->op_end()) Out << ", "; } if (CE->hasIndices()) { ArrayRef Indices = CE->getIndices(); for (unsigned i = 0, e = Indices.size(); i != e; ++i) Out << ", " << Indices[i]; } if (CE->isCast()) { Out << " to "; TypePrinter.print(CE->getType(), Out); } Out << ')'; return; } Out << ""; } static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context) { Out << "!{"; for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) { const Value *V = Node->getOperand(mi); if (V == 0) Out << "null"; else { TypePrinter->print(V->getType(), Out); Out << ' '; WriteAsOperandInternal(Out, Node->getOperand(mi), TypePrinter, Machine, Context); } if (mi + 1 != me) Out << ", "; } Out << "}"; } // Full implementation of printing a Value as an operand with support for // TypePrinting, etc. static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context) { if (V->hasName()) { PrintLLVMName(Out, V); return; } const Constant *CV = dyn_cast(V); if (CV && !isa(CV)) { assert(TypePrinter && "Constants require TypePrinting!"); WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context); return; } if (const InlineAsm *IA = dyn_cast(V)) { Out << "asm "; if (IA->hasSideEffects()) Out << "sideeffect "; if (IA->isAlignStack()) Out << "alignstack "; // We don't emit the AD_ATT dialect as it's the assumed default. if (IA->getDialect() == InlineAsm::AD_Intel) Out << "inteldialect "; Out << '"'; PrintEscapedString(IA->getAsmString(), Out); Out << "\", \""; PrintEscapedString(IA->getConstraintString(), Out); Out << '"'; return; } if (const MDNode *N = dyn_cast(V)) { if (N->isFunctionLocal()) { // Print metadata inline, not via slot reference number. WriteMDNodeBodyInternal(Out, N, TypePrinter, Machine, Context); return; } if (!Machine) { if (N->isFunctionLocal()) Machine = new SlotTracker(N->getFunction()); else Machine = new SlotTracker(Context); } int Slot = Machine->getMetadataSlot(N); if (Slot == -1) Out << ""; else Out << '!' << Slot; return; } if (const MDString *MDS = dyn_cast(V)) { Out << "!\""; PrintEscapedString(MDS->getString(), Out); Out << '"'; return; } if (V->getValueID() == Value::PseudoSourceValueVal || V->getValueID() == Value::FixedStackPseudoSourceValueVal) { V->print(Out); return; } char Prefix = '%'; int Slot; // If we have a SlotTracker, use it. if (Machine) { if (const GlobalValue *GV = dyn_cast(V)) { Slot = Machine->getGlobalSlot(GV); Prefix = '@'; } else { Slot = Machine->getLocalSlot(V); // If the local value didn't succeed, then we may be referring to a value // from a different function. Translate it, as this can happen when using // address of blocks. if (Slot == -1) if ((Machine = createSlotTracker(V))) { Slot = Machine->getLocalSlot(V); delete Machine; } } } else if ((Machine = createSlotTracker(V))) { // Otherwise, create one to get the # and then destroy it. if (const GlobalValue *GV = dyn_cast(V)) { Slot = Machine->getGlobalSlot(GV); Prefix = '@'; } else { Slot = Machine->getLocalSlot(V); } delete Machine; Machine = 0; } else { Slot = -1; } if (Slot != -1) Out << Prefix << Slot; else Out << ""; } void AssemblyWriter::init() { if (TheModule) TypePrinter.incorporateTypes(*TheModule); } AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M, AssemblyAnnotationWriter *AAW) : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW) { init(); } AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, const Module *M, AssemblyAnnotationWriter *AAW) : Out(o), TheModule(M), ModuleSlotTracker(createSlotTracker(M)), Machine(*ModuleSlotTracker), AnnotationWriter(AAW) { init(); } AssemblyWriter::~AssemblyWriter() { } void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { if (Operand == 0) { Out << ""; return; } if (PrintType) { TypePrinter.print(Operand->getType(), Out); Out << ' '; } WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); } void AssemblyWriter::writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope) { if (Ordering == NotAtomic) return; switch (SynchScope) { case SingleThread: Out << " singlethread"; break; case CrossThread: break; } switch (Ordering) { default: Out << " "; break; case Unordered: Out << " unordered"; break; case Monotonic: Out << " monotonic"; break; case Acquire: Out << " acquire"; break; case Release: Out << " release"; break; case AcquireRelease: Out << " acq_rel"; break; case SequentiallyConsistent: Out << " seq_cst"; break; } } void AssemblyWriter::writeParamOperand(const Value *Operand, AttributeSet Attrs, unsigned Idx) { if (Operand == 0) { Out << ""; return; } // Print the type TypePrinter.print(Operand->getType(), Out); // Print parameter attributes list if (Attrs.hasAttributes(Idx)) Out << ' ' << Attrs.getAsString(Idx); Out << ' '; // Print the operand WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); } void AssemblyWriter::printModule(const Module *M) { Machine.initialize(); if (!M->getModuleIdentifier().empty() && // Don't print the ID if it will start a new line (which would // require a comment char before it). M->getModuleIdentifier().find('\n') == std::string::npos) Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; if (!M->getDataLayout().empty()) Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; if (!M->getTargetTriple().empty()) Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; if (!M->getModuleInlineAsm().empty()) { // Split the string into lines, to make it easier to read the .ll file. std::string Asm = M->getModuleInlineAsm(); size_t CurPos = 0; size_t NewLine = Asm.find_first_of('\n', CurPos); Out << '\n'; while (NewLine != std::string::npos) { // We found a newline, print the portion of the asm string from the // last newline up to this newline. Out << "module asm \""; PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), Out); Out << "\"\n"; CurPos = NewLine+1; NewLine = Asm.find_first_of('\n', CurPos); } std::string rest(Asm.begin()+CurPos, Asm.end()); if (!rest.empty()) { Out << "module asm \""; PrintEscapedString(rest, Out); Out << "\"\n"; } } printTypeIdentities(); // Output all globals. if (!M->global_empty()) Out << '\n'; for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) { printGlobal(I); Out << '\n'; } // Output all aliases. if (!M->alias_empty()) Out << "\n"; for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) printAlias(I); // Output all of the functions. for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) printFunction(I); // Output all attribute groups. if (!Machine.as_empty()) { Out << '\n'; writeAllAttributeGroups(); } // Output named metadata. if (!M->named_metadata_empty()) Out << '\n'; for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), E = M->named_metadata_end(); I != E; ++I) printNamedMDNode(I); // Output metadata. if (!Machine.mdn_empty()) { Out << '\n'; writeAllMDNodes(); } } void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) { Out << '!'; StringRef Name = NMD->getName(); if (Name.empty()) { Out << " "; } else { if (isalpha(static_cast(Name[0])) || Name[0] == '-' || Name[0] == '$' || Name[0] == '.' || Name[0] == '_') Out << Name[0]; else Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F); for (unsigned i = 1, e = Name.size(); i != e; ++i) { unsigned char C = Name[i]; if (isalnum(static_cast(C)) || C == '-' || C == '$' || C == '.' || C == '_') Out << C; else Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F); } } Out << " = !{"; for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { if (i) Out << ", "; int Slot = Machine.getMetadataSlot(NMD->getOperand(i)); if (Slot == -1) Out << ""; else Out << '!' << Slot; } Out << "}\n"; } static void PrintLinkage(GlobalValue::LinkageTypes LT, formatted_raw_ostream &Out) { switch (LT) { case GlobalValue::ExternalLinkage: break; case GlobalValue::PrivateLinkage: Out << "private "; break; case GlobalValue::LinkerPrivateLinkage: Out << "linker_private "; break; case GlobalValue::LinkerPrivateWeakLinkage: Out << "linker_private_weak "; break; case GlobalValue::InternalLinkage: Out << "internal "; break; case GlobalValue::LinkOnceAnyLinkage: Out << "linkonce "; break; case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break; case GlobalValue::WeakAnyLinkage: Out << "weak "; break; case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break; case GlobalValue::CommonLinkage: Out << "common "; break; case GlobalValue::AppendingLinkage: Out << "appending "; break; case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; case GlobalValue::AvailableExternallyLinkage: Out << "available_externally "; break; } } static void PrintVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out) { switch (Vis) { case GlobalValue::DefaultVisibility: break; case GlobalValue::HiddenVisibility: Out << "hidden "; break; case GlobalValue::ProtectedVisibility: Out << "protected "; break; } } static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out) { switch (TLM) { case GlobalVariable::NotThreadLocal: break; case GlobalVariable::GeneralDynamicTLSModel: Out << "thread_local "; break; case GlobalVariable::LocalDynamicTLSModel: Out << "thread_local(localdynamic) "; break; case GlobalVariable::InitialExecTLSModel: Out << "thread_local(initialexec) "; break; case GlobalVariable::LocalExecTLSModel: Out << "thread_local(localexec) "; break; } } void AssemblyWriter::printGlobal(const GlobalVariable *GV) { if (GV->isMaterializable()) Out << "; Materializable\n"; WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent()); Out << " = "; if (!GV->hasInitializer() && GV->hasExternalLinkage()) Out << "external "; PrintLinkage(GV->getLinkage(), Out); PrintVisibility(GV->getVisibility(), Out); PrintThreadLocalModel(GV->getThreadLocalMode(), Out); if (unsigned AddressSpace = GV->getType()->getAddressSpace()) Out << "addrspace(" << AddressSpace << ") "; if (GV->hasUnnamedAddr()) Out << "unnamed_addr "; if (GV->isExternallyInitialized()) Out << "externally_initialized "; Out << (GV->isConstant() ? "constant " : "global "); TypePrinter.print(GV->getType()->getElementType(), Out); if (GV->hasInitializer()) { Out << ' '; writeOperand(GV->getInitializer(), false); } if (GV->hasSection()) { Out << ", section \""; PrintEscapedString(GV->getSection(), Out); Out << '"'; } if (GV->getAlignment()) Out << ", align " << GV->getAlignment(); printInfoComment(*GV); } void AssemblyWriter::printAlias(const GlobalAlias *GA) { if (GA->isMaterializable()) Out << "; Materializable\n"; // Don't crash when dumping partially built GA if (!GA->hasName()) Out << "<> = "; else { PrintLLVMName(Out, GA); Out << " = "; } PrintVisibility(GA->getVisibility(), Out); Out << "alias "; PrintLinkage(GA->getLinkage(), Out); const Constant *Aliasee = GA->getAliasee(); if (Aliasee == 0) { TypePrinter.print(GA->getType(), Out); Out << " <>"; } else { writeOperand(Aliasee, !isa(Aliasee)); } printInfoComment(*GA); Out << '\n'; } void AssemblyWriter::printTypeIdentities() { if (TypePrinter.NumberedTypes.empty() && TypePrinter.NamedTypes.empty()) return; Out << '\n'; // We know all the numbers that each type is used and we know that it is a // dense assignment. Convert the map to an index table. std::vector NumberedTypes(TypePrinter.NumberedTypes.size()); for (DenseMap::iterator I = TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end(); I != E; ++I) { assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?"); NumberedTypes[I->second] = I->first; } // Emit all numbered types. for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) { Out << '%' << i << " = type "; // Make sure we print out at least one level of the type structure, so // that we do not get %2 = type %2 TypePrinter.printStructBody(NumberedTypes[i], Out); Out << '\n'; } for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) { PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix); Out << " = type "; // Make sure we print out at least one level of the type structure, so // that we do not get %FILE = type %FILE TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out); Out << '\n'; } } /// printFunction - Print all aspects of a function. /// void AssemblyWriter::printFunction(const Function *F) { // Print out the return type and name. Out << '\n'; if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); if (F->isMaterializable()) Out << "; Materializable\n"; const AttributeSet &Attrs = F->getAttributes(); if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) { AttributeSet AS = Attrs.getFnAttributes(); std::string AttrStr; unsigned Idx = 0; for (unsigned E = AS.getNumSlots(); Idx != E; ++Idx) if (AS.getSlotIndex(Idx) == AttributeSet::FunctionIndex) break; for (AttributeSet::iterator I = AS.begin(Idx), E = AS.end(Idx); I != E; ++I) { Attribute Attr = *I; if (!Attr.isStringAttribute()) { if (!AttrStr.empty()) AttrStr += ' '; AttrStr += Attr.getAsString(); } } if (!AttrStr.empty()) Out << "; Function Attrs: " << AttrStr << '\n'; } if (F->isDeclaration()) Out << "declare "; else Out << "define "; PrintLinkage(F->getLinkage(), Out); PrintVisibility(F->getVisibility(), Out); // Print the calling convention. if (F->getCallingConv() != CallingConv::C) { PrintCallingConv(F->getCallingConv(), Out); Out << " "; } FunctionType *FT = F->getFunctionType(); if (Attrs.hasAttributes(AttributeSet::ReturnIndex)) Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' '; TypePrinter.print(F->getReturnType(), Out); Out << ' '; WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent()); Out << '('; Machine.incorporateFunction(F); // Loop over the arguments, printing them... unsigned Idx = 1; if (!F->isDeclaration()) { // If this isn't a declaration, print the argument names as well. for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) { // Insert commas as we go... the first arg doesn't get a comma if (I != F->arg_begin()) Out << ", "; printArgument(I, Attrs, Idx); Idx++; } } else { // Otherwise, print the types from the function type. for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { // Insert commas as we go... the first arg doesn't get a comma if (i) Out << ", "; // Output type... TypePrinter.print(FT->getParamType(i), Out); if (Attrs.hasAttributes(i+1)) Out << ' ' << Attrs.getAsString(i+1); } } // Finish printing arguments... if (FT->isVarArg()) { if (FT->getNumParams()) Out << ", "; Out << "..."; // Output varargs portion of signature! } Out << ')'; if (F->hasUnnamedAddr()) Out << " unnamed_addr"; if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes()); if (F->hasSection()) { Out << " section \""; PrintEscapedString(F->getSection(), Out); Out << '"'; } if (F->getAlignment()) Out << " align " << F->getAlignment(); if (F->hasGC()) Out << " gc \"" << F->getGC() << '"'; if (F->hasPrefixData()) { Out << " prefix "; writeOperand(F->getPrefixData(), true); } if (F->isDeclaration()) { Out << '\n'; } else { Out << " {"; // Output all of the function's basic blocks. for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) printBasicBlock(I); Out << "}\n"; } Machine.purgeFunction(); } /// printArgument - This member is called for every argument that is passed into /// the function. Simply print it out /// void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs, unsigned Idx) { // Output type... TypePrinter.print(Arg->getType(), Out); // Output parameter attributes list if (Attrs.hasAttributes(Idx)) Out << ' ' << Attrs.getAsString(Idx); // Output name, if available... if (Arg->hasName()) { Out << ' '; PrintLLVMName(Out, Arg); } } /// printBasicBlock - This member is called for each basic block in a method. /// void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { if (BB->hasName()) { // Print out the label if it exists... Out << "\n"; PrintLLVMName(Out, BB->getName(), LabelPrefix); Out << ':'; } else if (!BB->use_empty()) { // Don't print block # of no uses... Out << "\n;