AsmWriter.cpp revision 24b8a5d6e7c67b0fdfe98a5b6c3791b313dc904b
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 3009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 4009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 502b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// Note that these routines must be extremely tolerant of various errors in the 68f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner// LLVM code, because it can be used for debugging transformations. 702b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 8009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 10da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 1175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 12f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 13b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner#include "llvm/SlotCalculator.h" 143eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 15b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 16009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/Module.h" 1731bcdb822fe9133b1973de51519d34e5813a6184Chris Lattner#include "llvm/Constants.h" 18009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 19e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 207061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 217061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 22007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 23061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner#include "llvm/Support/CFG.h" 24cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 25cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 26007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 27c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 28a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintModulePass> 29a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerX("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 30a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintFunctionPass> 31a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerY("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 32f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 337b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 347b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 357b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table); 377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 38207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 39949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 40207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 41949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 42207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 43949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 4479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 45207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 46949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 47207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 48207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 49207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 50207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 51c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnerstatic SlotCalculator *createSlotCalculator(const Value *V) { 52c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner assert(!isa<Type>(V) && "Can't create an SC for a type!"); 53949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 5479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(FA->getParent(), true); 55949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 56c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(I->getParent()->getParent(), true); 57949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 58c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(BB->getParent(), true); 59949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 60c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(GV->getParent(), true); 61949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 6279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(Func, true); 63c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 64c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 65c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 66009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 6824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 6924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 7024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattnerstatic std::string getLLVMName(const std::string &Name) { 7124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 7224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 7324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 7424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 7524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 7624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 7724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 7824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 7924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 8024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 8124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 8224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 8324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 8424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 8524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 8624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 8724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "%"+Name; 8824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 8924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 90207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 91207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// If the module has a symbol table, take all global types and stuff their 92207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// names into the TypeNames map. 93207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 94207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 957b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 966e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 976e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 986e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::const_iterator PI = ST.find(Type::TypeTy); 996e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (PI != ST.end()) { 1006e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::type_const_iterator I = PI->second.begin(); 1016e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner for (; I != PI->second.end(); ++I) { 1026e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // As a heuristic, don't insert pointer to primitive types, because 1036e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // they are used too often to have a single useful name. 1046e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // 105949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const Type *Ty = cast<Type>(I->second); 1066e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!isa<PointerType>(Ty) || 1076e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner !cast<PointerType>(Ty)->getElementType()->isPrimitiveType()) 10824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner TypeNames.insert(std::make_pair(Ty, getLLVMName(I->first))); 109207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 110207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 111207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 112207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 113207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 114207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1157b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::string calcTypeName(const Type *Ty, 1167b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> &TypeStack, 1177b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames){ 118207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Ty->getDescription(); // Base case 119207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 120207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 1217b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 122207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return I->second; 123207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 124207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 125207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 126207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 127207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 128207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 129207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 130207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 131207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 132207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Slot < CurSize) 133207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return "\\" + utostr(CurSize-Slot); // Here's the upreference 134207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 135207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 136207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1377b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string Result; 138207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner switch (Ty->getPrimitiveID()) { 1396bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 140949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 1412761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; 1426bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner for (FunctionType::ParamTypes::const_iterator 1432761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = FTy->getParamTypes().begin(), 1442761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = FTy->getParamTypes().end(); I != E; ++I) { 1452761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != FTy->getParamTypes().begin()) 146207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 147207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 148207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 1492761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 1502761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (!FTy->getParamTypes().empty()) Result += ", "; 151207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 152207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 153207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 154207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 155207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 157949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 158207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "{ "; 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner for (StructType::ElementTypes::const_iterator 160207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner I = STy->getElementTypes().begin(), 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner E = STy->getElementTypes().end(); I != E; ++I) { 162207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != STy->getElementTypes().begin()) 163207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 165207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 166207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 167207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 168207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 169207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 170949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner Result = calcTypeName(cast<PointerType>(Ty)->getElementType(), 17102b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner TypeStack, TypeNames) + "*"; 172207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 173207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 174949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 175ff5c296498b3b1182e8d5e2515d0c15a7b558d4bChris Lattner Result = "[" + utostr(ATy->getNumElements()) + " x "; 176207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 177207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 178207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 1799e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 1809e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner Result = "opaque"; 1819e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 182207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 183b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Result = "<unrecognized-type>"; 184207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 186207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 187207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Result; 188207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 189207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 190207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 191207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// printTypeInt - The internal guts of printing out a type that has a 192207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// potentially named portion. 193207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 1947b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 1957b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 196207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 197207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 198207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 199207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Out << Ty->getDescription(); 200207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 201207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2027b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 203207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 204207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 205207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 206207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 207207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 208207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 2097b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 2107b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 211697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 212207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Out << TypeName; 213207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 214207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 215e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 216207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 217207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type, iff there is an entry in the modules symbol table for the specified 218207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type or one of it's component types. This is slower than a simple x << Type; 219207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 2207b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 2217b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner const Module *M) { 222207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " "; 223207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 224207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 225207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 2266e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 2277b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 228207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 229207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2307b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 231207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 2327b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 233207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 234207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 235207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2367b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 2377b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 2387b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 2397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 24066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 24166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << (CB == ConstantBool::True ? "true" : "false"); 24266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 24366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 24466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 24566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 24666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 24766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 24866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 24966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 25066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 25166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 25266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 25366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 25466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 25566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 25666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 25766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 25866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 25966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 260b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 26166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 26266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 26366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << StrVal; return; 26466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 26566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 26666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 26766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 26866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 26966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Behave nicely in the face of C TBAA rules... see: 27066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // http://www.nullstone.com/htmls/category/aliastyp.htm 27166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 27266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner double Val = CFP->getValue(); 27366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner char *Ptr = (char*)&Val; 27466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 27566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 27666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "0x" << utohexstr(*(uint64_t*)Ptr); 27766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 27866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 279e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner if (CA->getNumOperands() > 5 && CA->isNullValue()) { 280e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner Out << "zeroinitializer"; 281e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner return; 282e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner } 283e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner 28466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 28566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 28666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 28766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 28866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 28966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 29066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (ETy == Type::SByteTy) 29166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) 29266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 29366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner isString = false; 29466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner break; 29566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 29666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 29766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (isString) { 29866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 29966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 300c07736a397012499e337c994f7f952b07c709544Chris Lattner unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue(); 30166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 302fc94446777fcdff03fdc09539bab25200936b43eChris Lattner if (isprint(C) && C != '"' && C != '\\') { 30366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << C; 30466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 30566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << '\\' 30666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 30766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 30866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 30966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 31066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 31166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 31266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 3137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "["; 3147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 3157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 31666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 3177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 3187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 3207a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 32166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 3227a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 3237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner TypeTable, Table); 3247a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3267a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 3277a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3287a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 329e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner if (CS->getNumOperands() > 5 && CS->isNullValue()) { 330e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner Out << "zeroinitializer"; 331e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner return; 332e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner } 333e9a64ea38e6701f76d2767d8e467083e8ba35920Chris Lattner 3347a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "{"; 3357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CS->getNumOperands()) { 3367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 3377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 3387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 3407a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3427a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1; i < CS->getNumOperands(); i++) { 3437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 3447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 3457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3467a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 3477a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3487a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3497a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3507a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 3527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 3537a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 3547a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3557e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { 35666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const GlobalValue *V = PR->getValue(); 35766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (V->hasName()) { 35824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 35966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (Table) { 36066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner int Slot = Table->getValSlot(V); 36166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (Slot >= 0) 36266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "%" << Slot; 36366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner else 36466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "<pointer reference badref>"; 36566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 36666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "<pointer reference without context info>"; 36766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 368b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 369c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 37038d877365030f90b099d53ab6a66bd62271e330fChris Lattner Out << CE->getOpcodeName() << " ("; 371b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 372b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 373b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 374b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table); 375b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 376c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 377b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 378b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 3791c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner if (CE->getOpcode() == Instruction::Cast) { 38095586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 38195586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 38295586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 3831c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner Out << ")"; 38495586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 3857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 386b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 3877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3887a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 3897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3907a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 3927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 3937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// whole instruction that generated it. 3947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// 3957b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 3967b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 3977b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 3987a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 3997a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 4007a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintName && V->hasName()) { 40124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 4027a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 403949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CV = dyn_cast<Constant>(V)) { 4047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteConstantInt(Out, CV, PrintName, TypeTable, Table); 4057a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 4067a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 4077a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table) { 4087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Slot = Table->getValSlot(V); 4097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 410949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Type *Ty = dyn_cast<Type>(V)) { 4117a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << Ty->getDescription(); 4127a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner return; 4137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Table = createSlotCalculator(V); 4167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } 4177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Slot = Table->getValSlot(V); 4197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner delete Table; 4207a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Slot >= 0) Out << "%" << Slot; 4227a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner else if (PrintName) 4237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "<badref>"; // Not embeded into a location? 4247a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4267a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 4277a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4287a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 429207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 430207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 431207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 432207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// whole instruction that generated it. 433207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 4347b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType, 4357b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, const Module *Context) { 4367b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 437607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 4387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4396e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 440607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 441207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 4427a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 4437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 4447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 445607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 446622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 447622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 448622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 449622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 450d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 451007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 4527b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &Out; 453009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator &Table; 454c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 4557b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 456009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 4577b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner inline AssemblyWriter(std::ostream &o, SlotCalculator &Tab, const Module *M) 458c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner : Out(o), Table(Tab), TheModule(M) { 459c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 460c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 461c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 462c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 463207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 464009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 465009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 466c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 467c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 46879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 469c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 4707e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 471e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 472da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 473009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 47466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 47566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 476009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 477c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 478c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 479e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 480c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 48179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 48273e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 483c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 4847e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 4852761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4862761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 4872761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 4882761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 4897b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 4902761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner return printTypeInt(Out, Ty, TypeNames); 4912761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4922761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4932761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 4942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 4952761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 4967b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 497c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 498e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 499e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 5007e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 501009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 502009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 503009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 5042761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 5052761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// without considering any symbolic types that we may have equal to it. 5062761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// 5077b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 5087e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 5092761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 5102761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner for (FunctionType::ParamTypes::const_iterator 5112761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = FTy->getParamTypes().begin(), 5122761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = FTy->getParamTypes().end(); I != E; ++I) { 5132761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != FTy->getParamTypes().begin()) 5142761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ", "; 5157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 5162761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5172761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 5182761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (!FTy->getParamTypes().empty()) Out << ", "; 5192761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "..."; 5202761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5212761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ")"; 5227e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 5232761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "{ "; 5242761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner for (StructType::ElementTypes::const_iterator 5252761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = STy->getElementTypes().begin(), 5262761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = STy->getElementTypes().end(); I != E; ++I) { 5272761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != STy->getElementTypes().begin()) 5282761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ", "; 5292761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 5302761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5312761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << " }"; 5327e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 5332761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(PTy->getElementType()) << "*"; 5347e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 5352761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "[" << ATy->getNumElements() << " x "; 5362761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(ATy->getElementType()) << "]"; 5377e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 53826c6915539bbe3393450ece5d82d7d9ea546d417Chris Lattner Out << "opaque"; 5392761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 540b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 541b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<unknown derived type>"; 5422761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 5432761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5442761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner return Out; 5452761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 5462761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5472761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 548007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 549007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner bool PrintName) { 550c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (PrintType) { Out << " "; printType(Operand->getType()); } 5517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Table); 552007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 553007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 554007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 555c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 55661a909a6fd618a17f9d28f5ab2237f7fb179f8a8Chris Lattner Out << "target endian = " << (M->isLittleEndian() ? "little" : "big") << "\n"; 55761a909a6fd618a17f9d28f5ab2237f7fb179f8a8Chris Lattner Out << "target pointersize = " << (M->has32BitPointers() ? 32 : 64) << "\n"; 55861a909a6fd618a17f9d28f5ab2237f7fb179f8a8Chris Lattner 559007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 5606e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 56170cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 5627e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 5637e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 564007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 56503e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "\nimplementation ; Functions:\n"; 5665efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 567b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of the functions... 5687e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 5697e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 570009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 571009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 572c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 57324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; 574d70684f7585a85c4248c1c224059478108741c70Chris Lattner 5754ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!GV->hasInitializer()) 5764ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner Out << "external "; 5774ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 5784ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 5794ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::InternalLinkage: Out << "internal "; break; 5804ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 5814ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::AppendingLinkage: Out << "appending "; break; 5824ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 5834ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 584d70684f7585a85c4248c1c224059478108741c70Chris Lattner 585c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << (GV->isConstant() ? "constant " : "global "); 5867a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 587d70684f7585a85c4248c1c224059478108741c70Chris Lattner 588d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (GV->hasInitializer()) 589d70684f7585a85c4248c1c224059478108741c70Chris Lattner writeOperand(GV->getInitializer(), false, false); 590d70684f7585a85c4248c1c224059478108741c70Chris Lattner 5917e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 592697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 59370cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 59470cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 595009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 596c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printSymbolTable - Run through symbol table looking for named constants 597007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// if a named constant is found, emit it's declaration... 598007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// 599c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 600007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) { 601007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator I = ST.type_begin(TI->first); 602007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator End = ST.type_end(TI->first); 603007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 604007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (; I != End; ++I) { 605007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner const Value *V = I->second; 606949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CPV = dyn_cast<Constant>(V)) { 607c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printConstant(CPV); 608949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Type *Ty = dyn_cast<Type>(V)) { 60924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << "\t" << getLLVMName(I->first) << " = type "; 6102761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6112761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // Make sure we print out at least one level of the type structure, so 6122761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // that we do not get %FILE = type %FILE 6132761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6142761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printTypeAtLeastOneLevel(Ty) << "\n"; 615007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 616007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 617739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 618009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 619009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 620009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 621c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printConstant - Print out a constant pool entry... 622009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 623e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 624007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 625007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 626009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6271333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 62824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << "\t" << getLLVMName(CPV->getName()) << " ="; 629009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 630009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 6317a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 632009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6337e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 634697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 635009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 636009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 637b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner// printFunction - Print all aspects of a function. 638009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 6397e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 640009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 6414ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner Out << "\n"; 6424ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 6434ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 6444ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner Out << "declare "; 6454ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 6464ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 6474ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::InternalLinkage: Out << "internal "; break; 6484ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 6494ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::AppendingLinkage: Out << "appending "; break; 6504ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 6514ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 6524ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 65324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner printType(F->getReturnType()) << " " << getLLVMName(F->getName()) << "("; 6547e70829632f82de15db187845666aaca6e04b792Chris Lattner Table.incorporateFunction(F); 655007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 656c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 6577e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 658007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 65969da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 66069da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 661007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 662007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 6637e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 6647e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->getParamTypes().size()) Out << ", "; 665007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Out << "..."; // Output varargs portion of signature! 666007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 66703e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << ")"; 668007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 6697e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 67003e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "\n"; 67103e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 67203e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << " {"; 673007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 674b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 6757e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 6767e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 677007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 67803e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "}\n"; 679007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 680007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 681b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner Table.purgeFunction(); 682009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 683009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 68473e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner// printArgument - This member is called for every argument that 685b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner// is passed into the function. Simply print it out 686009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 68773e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 688009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 6897e70829632f82de15db187845666aaca6e04b792Chris Lattner if (Arg != &Arg->getParent()->afront()) Out << ", "; 690009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 691009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 692c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 693009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 694009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 695009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 69624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << " " << getLLVMName(Arg->getName()); 697009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else if (Table.getValSlot(Arg) < 0) 698009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "<badref>"; 699009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 700009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 701c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printBasicBlock - This member is called for each basic block in a methd. 702009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 703c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 704009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 705061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << "\n" << BB->getName() << ":"; 706afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 707009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner int Slot = Table.getValSlot(BB); 708b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "\n; <label>:"; 709009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Slot >= 0) 710bc0e998c497446f5448425b3cbd7f8f19a458764Misha Brukman Out << Slot; // Extra newline separates out label's 711009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else 712b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "<badref>"; 713061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 714061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner 715061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner // Output predecessors for the block... 716061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << "\t\t;"; 717061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 718061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner 719061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner if (PI == PE) { 720061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << " No predecessors!"; 721061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } else { 722061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << " preds ="; 723061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner writeOperand(*PI, false, true); 724061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner for (++PI; PI != PE; ++PI) { 725061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << ","; 726061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner writeOperand(*PI, false, true); 727061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 728009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 729afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner 730afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner Out << "\n"; 731009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 732007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 7337e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 7347e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 735009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 736009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 737e02fa8551d20081534afa46e0976811687e5183aChris Lattner 738e02fa8551d20081534afa46e0976811687e5183aChris Lattner// printInfoComment - Print a little comment after the instruction indicating 739e02fa8551d20081534afa46e0976811687e5183aChris Lattner// which slot it occupies. 740e02fa8551d20081534afa46e0976811687e5183aChris Lattner// 7417e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 7427e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 743c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << "\t\t; <"; 7447e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(V.getType()) << ">"; 745e02fa8551d20081534afa46e0976811687e5183aChris Lattner 7467e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 7477e70829632f82de15db187845666aaca6e04b792Chris Lattner int Slot = Table.getValSlot(&V); // Print out the def slot taken... 748e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (Slot >= 0) Out << ":" << Slot; 749e02fa8551d20081534afa46e0976811687e5183aChris Lattner else Out << ":<badref>"; 750e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 7517e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << " [#uses=" << V.use_size() << "]"; // Output # uses 752e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 753e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 754e02fa8551d20081534afa46e0976811687e5183aChris Lattner 755c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printInstruction - This member is called for each Instruction in a methd. 756009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 7577e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 758009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\t"; 759009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 760009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 7617e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 76224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(I.getName()) << " = "; 763009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 764009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 7657e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << I.getOpcodeName(); 766009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 767009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 7687e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 769009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 770009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 7717e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 7727e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 773009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 774009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 775009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 7767e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 777009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 77894dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 779009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 7807e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(Operand , true); Out << ","; 7817e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); Out << " ["; 782009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7837e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 784009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t\t"; 7857e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op ), true); Out << ","; 7867e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 787009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 788009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t]"; 789b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 790c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 7917e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 792eed1fc79735c3ade3dddc0d45eec2c9811969e21Chris Lattner Out << " "; 793009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7947e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 7958f410cac044a21a94afece41345ccd9b72047675Chris Lattner if (op) Out << ", "; 7968f410cac044a21a94afece41345ccd9b72047675Chris Lattner Out << "["; 7977e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op ), false); Out << ","; 7987e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), false); Out << " ]"; 799c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 800e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 801009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " void"; 802e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 8037a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 8047a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 8057a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 806268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 8077a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 808b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 8097a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 810268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 8117a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 81294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner (!isa<PointerType>(RetTy) || 813c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 814268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner Out << " "; printType(RetTy); 815268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 816268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 817268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 818268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 819009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "("; 8207e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 8217e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 822009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 8237e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 824009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 825009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 826009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " )"; 8277e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 8287a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 8297a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 8307a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 8317a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 8327a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 8337a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 8347a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 8357a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 8367a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 8377a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner (!isa<PointerType>(RetTy) || 8387a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 8397a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner Out << " "; printType(RetTy); 8407a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 8417a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 8427a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 8437a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 8447a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 845e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << "("; 8467e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 8477e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 848e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << ","; 8497e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 850e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 851e02fa8551d20081534afa46e0976811687e5183aChris Lattner 852e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " )\n\t\t\tto"; 853e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 854e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " except"; 855e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getExceptionalDest(), true); 856e02fa8551d20081534afa46e0976811687e5183aChris Lattner 8577e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 858c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 85994dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 86094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 861c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner Out << ","; 86294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 863009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 864e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 8658f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner writeOperand(Operand, true); 866c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " to "; 8677e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 8688f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner } else if (isa<VarArgInst>(I)) { 8698f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner writeOperand(Operand, true); 8708f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner Out << ", "; 8718f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 872009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 873009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 874009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 875009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 876009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 877009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 878009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 879009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 880ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner // Shift Left & Right print both types even for Ubyte LHS 881ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (isa<ShiftInst>(I)) { 882ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 883ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 884ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 885ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 886ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 887ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 888ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 889ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 890009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 891009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 892ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner 893c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 894c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 895ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 896c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 897009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8987e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 899009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (i) Out << ","; 9007e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 901009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 902009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 903009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 904e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 905697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 906009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 907009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 908009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 909009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 910009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 911009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 912009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 913009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 91475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Module::print(std::ostream &o) const { 91575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(this, true); 91675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, this); 91775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 918009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 919009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 92075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 92175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 92275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, getParent()); 92375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 924b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 925b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 92675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Function::print(std::ostream &o) const { 92775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 92875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, getParent()); 929009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 93075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 931009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 932009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 93375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid BasicBlock::print(std::ostream &o) const { 93475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 93575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, 93675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner getParent() ? getParent()->getParent() : 0); 93775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 93875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 939009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 94075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Instruction::print(std::ostream &o) const { 94175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 94275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(F, true); 94375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0); 944009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 94575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 94675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 947009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 94875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 94975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 9503bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 9513bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner // Handle CPR's special, because they have context information... 9523bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { 9533bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner CPR->getValue()->print(o); // Print as a global value, with context info. 9543bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner return; 9553bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner } 9563bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 95766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner o << " " << getType()->getDescription() << " "; 95866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 9597b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeTable; 96066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner WriteConstantInt(o, this, false, TypeTable, 0); 961009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 962009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 96375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Type::print(std::ostream &o) const { 96475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 96575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 96675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 96775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 968009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 969009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 97073e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 97175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getType() << " " << getName(); 97275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 973009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 97475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Value::dump() const { print(std::cerr); } 975009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 97675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 97775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 97875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 979da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 980da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 981da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 982da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 983da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = new SlotCalculator(M, true); 984da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner AW = new AssemblyWriter(Out, *SC, M); 985da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 986da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 987da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 988da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 989da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 990da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 991da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 992da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 993da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 994da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 995da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter &CachedWriter::operator<<(const Value *V) { 996da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 997da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner switch (V->getValueType()) { 998da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ConstantVal: 99966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner case Value::ArgumentVal: AW->writeOperand(V, true, true); break; 1000949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner case Value::TypeVal: AW->write(cast<Type>(V)); break; 1001da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 1002da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 100379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionVal: AW->write(cast<Function>(V)); break; 1004da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 1005da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner default: Out << "<unknown value type: " << V->getValueType() << ">"; break; 1006da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1007da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 1008da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1009