AsmWriter.cpp revision ffd9bf404cd36c93d82b0080113ccc6d230915b3
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 602b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// LLVM code, because of of the primary uses of it is for debugging 702b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// transformations. 802b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 1275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 13f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 14b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner#include "llvm/SlotCalculator.h" 153eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 16b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 17009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/Module.h" 1831bcdb822fe9133b1973de51519d34e5813a6184Chris Lattner#include "llvm/Constants.h" 19009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 20e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 217061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 227061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 23007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 24061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner#include "llvm/Support/CFG.h" 25cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 26cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 27007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 28697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::string; 29697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::map; 30697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::vector; 31697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::ostream; 32c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 33a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintModulePass> 34a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerX("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 35a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintFunctionPass> 36a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerY("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 37f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattnerstatic void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, 397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner map<const Type *, string> &TypeTable, 407a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table); 417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 42207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 4373e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner if (const Argument *MA = dyn_cast<const Argument>(V)) 44207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 45207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V)) 46207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 47207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner else if (const Instruction *I = dyn_cast<const Instruction>(V)) { 4879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 49207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 5079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const GlobalValue *GV = dyn_cast<const GlobalValue>(V)) 51207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 52207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 53207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 54207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 55c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnerstatic SlotCalculator *createSlotCalculator(const Value *V) { 56c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner assert(!isa<Type>(V) && "Can't create an SC for a type!"); 5773e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner if (const Argument *FA = dyn_cast<const Argument>(V)) { 5879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(FA->getParent(), true); 59c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } else if (const Instruction *I = dyn_cast<const Instruction>(V)) { 60c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(I->getParent()->getParent(), true); 61c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V)) { 62c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(BB->getParent(), true); 6379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const GlobalVariable *GV = dyn_cast<const GlobalVariable>(V)){ 64c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(GV->getParent(), true); 6579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const Function *Func = dyn_cast<const Function>(V)) { 6679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(Func, true); 67c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 68c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 69c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 70009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 71207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 72207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// If the module has a symbol table, take all global types and stuff their 73207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// names into the TypeNames map. 74207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 75207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 76207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 776e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 786e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 796e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::const_iterator PI = ST.find(Type::TypeTy); 806e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (PI != ST.end()) { 816e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::type_const_iterator I = PI->second.begin(); 826e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner for (; I != PI->second.end(); ++I) { 836e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // As a heuristic, don't insert pointer to primitive types, because 846e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // they are used too often to have a single useful name. 856e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // 866e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const Type *Ty = cast<const Type>(I->second); 876e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!isa<PointerType>(Ty) || 886e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner !cast<PointerType>(Ty)->getElementType()->isPrimitiveType()) 896e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner TypeNames.insert(std::make_pair(Ty, "%"+I->first)); 90207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 91207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 92207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 93207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 94207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 95207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 96207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic string calcTypeName(const Type *Ty, vector<const Type *> &TypeStack, 97207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 98207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Ty->getDescription(); // Base case 99207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 100207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 101207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string>::iterator I = TypeNames.find(Ty); 102207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return I->second; 103207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 104207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 105207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 106207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 107207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 108207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 109207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 110207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 111207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 112207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Slot < CurSize) 113207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return "\\" + utostr(CurSize-Slot); // Here's the upreference 114207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 115207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 116207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 117207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner string Result; 118207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner switch (Ty->getPrimitiveID()) { 1196bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 1202761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner const FunctionType *FTy = cast<const FunctionType>(Ty); 1212761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; 1226bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner for (FunctionType::ParamTypes::const_iterator 1232761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = FTy->getParamTypes().begin(), 1242761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = FTy->getParamTypes().end(); I != E; ++I) { 1252761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != FTy->getParamTypes().begin()) 126207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 127207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 128207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 1292761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 1302761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (!FTy->getParamTypes().empty()) Result += ", "; 131207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 132207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 133207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 134207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 135207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 136207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 137207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const StructType *STy = cast<const StructType>(Ty); 138207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "{ "; 139207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner for (StructType::ElementTypes::const_iterator 140207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner I = STy->getElementTypes().begin(), 141207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner E = STy->getElementTypes().end(); I != E; ++I) { 142207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != STy->getElementTypes().begin()) 143207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 144207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 145207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 146207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 147207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 148207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 149207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 1507a1767520611d9ff6face702068de858e1cadf2cChris Lattner Result = calcTypeName(cast<const PointerType>(Ty)->getElementType(), 15102b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner TypeStack, TypeNames) + "*"; 152207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 153207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 154207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const ArrayType *ATy = cast<const ArrayType>(Ty); 155ff5c296498b3b1182e8d5e2515d0c15a7b558d4bChris Lattner Result = "[" + utostr(ATy->getNumElements()) + " x "; 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 157207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 158207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 160b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Result = "<unrecognized-type>"; 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 162207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 163207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Result; 165207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 166207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 167207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 168207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// printTypeInt - The internal guts of printing out a type that has a 169207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// potentially named portion. 170207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 171207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic ostream &printTypeInt(ostream &Out, const Type *Ty, 172207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 173207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 174207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 175207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 176207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Out << Ty->getDescription(); 177207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 178207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 179207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string>::iterator I = TypeNames.find(Ty); 180207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 181207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 182207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 183207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 184207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 186207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner vector<const Type *> TypeStack; 187207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 188697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 189207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Out << TypeName; 190207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 191207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 192e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 193207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 194207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type, iff there is an entry in the modules symbol table for the specified 195207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type or one of it's component types. This is slower than a simple x << Type; 196207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 197207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerostream &WriteTypeSymbolic(ostream &Out, const Type *Ty, const Module *M) { 198207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " "; 199207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 200207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 201207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 2026e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 203207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> TypeNames; 204207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 205207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2067b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 207207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 2087b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 209207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 210207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 211207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2127a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattnerstatic void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, 2137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner map<const Type *, string> &TypeTable, 2147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 21566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 21666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << (CB == ConstantBool::True ? "true" : "false"); 21766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 21866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 21966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 22066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 22166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 22266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 22366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 22466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 22566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 22666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 22766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 22866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 22966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 23066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 23166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 23266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 23366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 23466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 23566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner (StrVal[0] >= '0' && StrVal[0] <= '9'))) 23666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 23766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 23866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << StrVal; return; 23966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 24066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 24166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 24266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 24366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 24466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Behave nicely in the face of C TBAA rules... see: 24566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // http://www.nullstone.com/htmls/category/aliastyp.htm 24666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 24766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner double Val = CFP->getValue(); 24866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner char *Ptr = (char*)&Val; 24966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 25066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 25166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "0x" << utohexstr(*(uint64_t*)Ptr); 25266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 25366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 25466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 25566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 25666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 25766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 25866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 25966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 26066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (ETy == Type::SByteTy) 26166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) 26266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 26366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner isString = false; 26466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner break; 26566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 26666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 26766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (isString) { 26866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 26966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 27066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner unsigned char C = (ETy == Type::SByteTy) ? 27166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner (unsigned char)cast<ConstantSInt>(CA->getOperand(i))->getValue() : 27266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner (unsigned char)cast<ConstantUInt>(CA->getOperand(i))->getValue(); 27366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 274fc94446777fcdff03fdc09539bab25200936b43eChris Lattner if (isprint(C) && C != '"' && C != '\\') { 27566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << C; 27666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 27766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << '\\' 27866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 27966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 28066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 28166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 28266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 28366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 28466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 2857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "["; 2867a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 2877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 28866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 2897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 2907a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 2917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 2927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 29366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 2947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 2957a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner TypeTable, Table); 2967a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 2977a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 2987a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 2997a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3007a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 3017a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "{"; 3027a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CS->getNumOperands()) { 3037a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 3047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 3057a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3067a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 3077a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1; i < CS->getNumOperands(); i++) { 3107a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 3117a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 3127a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 3147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 3197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 3207a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 3217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3227e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { 32366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const GlobalValue *V = PR->getValue(); 32466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (V->hasName()) { 32566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "%" << V->getName(); 32666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (Table) { 32766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner int Slot = Table->getValSlot(V); 32866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (Slot >= 0) 32966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "%" << Slot; 33066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner else 33166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "<pointer reference badref>"; 33266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 33366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "<pointer reference without context info>"; 33466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 335b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 336c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 33738d877365030f90b099d53ab6a66bd62271e330fChris Lattner Out << CE->getOpcodeName() << " ("; 338b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 339b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 340b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 341b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table); 342b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 343c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 344b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 345b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 3461c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner if (CE->getOpcode() == Instruction::Cast) { 34795586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 34895586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 34995586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 3501c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner Out << ")"; 35195586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 3527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 353b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 3547a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3557a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 3567a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3577a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3587a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 3597a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 3607a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// whole instruction that generated it. 3617a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner// 3627a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattnerstatic void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, 3637a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner map<const Type *, string> &TypeTable, 3647a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 3657a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 3667a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintName && V->hasName()) { 3677a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "%" << V->getName(); 3687a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 3697a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (const Constant *CV = dyn_cast<const Constant>(V)) { 3707a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteConstantInt(Out, CV, PrintName, TypeTable, Table); 3717a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 3727a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 3737a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table) { 3747a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Slot = Table->getValSlot(V); 3757a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 3767a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (const Type *Ty = dyn_cast<const Type>(V)) { 3777a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << Ty->getDescription(); 3787a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner return; 3797a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3807a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3817a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Table = createSlotCalculator(V); 3827a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } 3837a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Slot = Table->getValSlot(V); 3857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner delete Table; 3867a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Slot >= 0) Out << "%" << Slot; 3887a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner else if (PrintName) 3897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "<badref>"; // Not embeded into a location? 3907a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 3937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 395207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 396207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 397207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 398207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// whole instruction that generated it. 399207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 400207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerostream &WriteAsOperand(ostream &Out, const Value *V, bool PrintType, 401607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner bool PrintName, const Module *Context) { 4027a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner map<const Type *, string> TypeNames; 403607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 4047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4056e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 406607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 407207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 4087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 4097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 4107a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 411607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 412622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 413622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 414622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 415622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 416d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 417007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 418009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner ostream &Out; 419009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator &Table; 420c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 421c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner map<const Type *, string> TypeNames; 422009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 423c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline AssemblyWriter(ostream &o, SlotCalculator &Tab, const Module *M) 424c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner : Out(o), Table(Tab), TheModule(M) { 425c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 426c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 427c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 428c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 429207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 430009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 431009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 432c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 433c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 43479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 435c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 4367e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 437e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 438da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 439009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 44066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 44166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 442009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 443c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 444c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 445e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 446c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 44779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 44873e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 449c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 4507e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 4512761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4522761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 4532761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 4542761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 4552761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner ostream &printType(const Type *Ty) { 4562761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner return printTypeInt(Out, Ty, TypeNames); 4572761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4582761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4592761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 4602761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 4612761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 4622761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner ostream &printTypeAtLeastOneLevel(const Type *Ty); 463c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 464e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 465e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 4667e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 467009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 468009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 469009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 4702761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 4712761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// without considering any symbolic types that we may have equal to it. 4722761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner// 4732761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattnerostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 4747e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 4752761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 4762761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner for (FunctionType::ParamTypes::const_iterator 4772761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = FTy->getParamTypes().begin(), 4782761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = FTy->getParamTypes().end(); I != E; ++I) { 4792761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != FTy->getParamTypes().begin()) 4802761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ", "; 4817a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 4822761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4832761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 4842761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (!FTy->getParamTypes().empty()) Out << ", "; 4852761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "..."; 4862761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4872761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ")"; 4887e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 4892761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "{ "; 4902761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner for (StructType::ElementTypes::const_iterator 4912761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner I = STy->getElementTypes().begin(), 4922761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner E = STy->getElementTypes().end(); I != E; ++I) { 4932761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (I != STy->getElementTypes().begin()) 4942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << ", "; 4952761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 4962761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4972761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << " }"; 4987e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 4992761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(PTy->getElementType()) << "*"; 5007e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 5012761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "[" << ATy->getNumElements() << " x "; 5022761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(ATy->getElementType()) << "]"; 5037e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 5049e77f77687bdeece2a66ed9103379f6da3bbc46eChris Lattner Out << OTy->getDescription(); 5052761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 506b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 507b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<unknown derived type>"; 5082761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 5092761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5102761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner return Out; 5112761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 5122761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5132761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 514007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 515007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner bool PrintName) { 516c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (PrintType) { Out << " "; printType(Operand->getType()); } 5177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Table); 518007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 519007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 520007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 521c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 522007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 5236e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 52470cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 5257e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 5267e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 527007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 52803e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "\nimplementation ; Functions:\n"; 5295efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 530b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of the functions... 5317e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 5327e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 533009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 534009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 535c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 53670cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner if (GV->hasName()) Out << "%" << GV->getName() << " = "; 537d70684f7585a85c4248c1c224059478108741c70Chris Lattner 538dda719665ba2ffd2eb1c32a0d2daa3921448db7cChris Lattner if (GV->hasInternalLinkage()) Out << "internal "; 5390c5e36211801f14d02d7fec1393bed450b68c79fChris Lattner if (!GV->hasInitializer()) Out << "external "; 540d70684f7585a85c4248c1c224059478108741c70Chris Lattner 541c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << (GV->isConstant() ? "constant " : "global "); 5427a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 543d70684f7585a85c4248c1c224059478108741c70Chris Lattner 544d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (GV->hasInitializer()) 545d70684f7585a85c4248c1c224059478108741c70Chris Lattner writeOperand(GV->getInitializer(), false, false); 546d70684f7585a85c4248c1c224059478108741c70Chris Lattner 5477e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 548697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 54970cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 55070cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 551009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 552c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printSymbolTable - Run through symbol table looking for named constants 553007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// if a named constant is found, emit it's declaration... 554007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// 555c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 556007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) { 557007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator I = ST.type_begin(TI->first); 558007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator End = ST.type_end(TI->first); 559007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 560007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (; I != End; ++I) { 561007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner const Value *V = I->second; 562e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner if (const Constant *CPV = dyn_cast<const Constant>(V)) { 563c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printConstant(CPV); 5641d87bcf4909b06dcd86320722653341f08b8b396Chris Lattner } else if (const Type *Ty = dyn_cast<const Type>(V)) { 5652761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Out << "\t%" << I->first << " = type "; 5662761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5672761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // Make sure we print out at least one level of the type structure, so 5682761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // that we do not get %FILE = type %FILE 5692761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 5702761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printTypeAtLeastOneLevel(Ty) << "\n"; 571007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 572007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 573739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 574009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 575009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 576009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 577c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printConstant - Print out a constant pool entry... 578009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 579e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 580007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 581007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 582009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 5831333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 5847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "\t%" << CPV->getName() << " ="; 585009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 586009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 5877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 588009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 5897e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 590697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 591009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 592009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 593b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner// printFunction - Print all aspects of a function. 594009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 5957e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 596009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 5977e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << "\n" << (F->isExternal() ? "declare " : "") 5987e70829632f82de15db187845666aaca6e04b792Chris Lattner << (F->hasInternalLinkage() ? "internal " : ""); 5997e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(F->getReturnType()) << " %" << F->getName() << "("; 6007e70829632f82de15db187845666aaca6e04b792Chris Lattner Table.incorporateFunction(F); 601007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 602c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 6037e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 604007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 60569da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 60669da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 607007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 608007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 6097e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 6107e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->getParamTypes().size()) Out << ", "; 611007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Out << "..."; // Output varargs portion of signature! 612007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 61303e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << ")"; 614007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 6157e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 61603e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "\n"; 61703e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 61803e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << " {"; 619007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 620b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 6217e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 6227e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 623007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 62403e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner Out << "}\n"; 625007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 626007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 627b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner Table.purgeFunction(); 628009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 629009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 63073e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner// printArgument - This member is called for every argument that 631b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner// is passed into the function. Simply print it out 632009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 63373e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 634009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 6357e70829632f82de15db187845666aaca6e04b792Chris Lattner if (Arg != &Arg->getParent()->afront()) Out << ", "; 636009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 637009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 638c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 639009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 640009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 641009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 642009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " %" << Arg->getName(); 643009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else if (Table.getValSlot(Arg) < 0) 644009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "<badref>"; 645009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 646009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 647c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printBasicBlock - This member is called for each basic block in a methd. 648009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 649c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 650009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 651061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << "\n" << BB->getName() << ":"; 652afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 653009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner int Slot = Table.getValSlot(BB); 654b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "\n; <label>:"; 655009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Slot >= 0) 656b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << Slot; // Extra newline seperates out label's 657009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else 658b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "<badref>"; 659061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 660061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner 661061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner // Output predecessors for the block... 662061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << "\t\t;"; 663061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 664061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner 665061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner if (PI == PE) { 666061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << " No predecessors!"; 667061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } else { 668061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << " preds ="; 669061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner writeOperand(*PI, false, true); 670061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner for (++PI; PI != PE; ++PI) { 671061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner Out << ","; 672061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner writeOperand(*PI, false, true); 673061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 674009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 675afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner 676afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner Out << "\n"; 677009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 678007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 6797e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 6807e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 681009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 682009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 683e02fa8551d20081534afa46e0976811687e5183aChris Lattner 684e02fa8551d20081534afa46e0976811687e5183aChris Lattner// printInfoComment - Print a little comment after the instruction indicating 685e02fa8551d20081534afa46e0976811687e5183aChris Lattner// which slot it occupies. 686e02fa8551d20081534afa46e0976811687e5183aChris Lattner// 6877e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 6887e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 689c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << "\t\t; <"; 6907e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(V.getType()) << ">"; 691e02fa8551d20081534afa46e0976811687e5183aChris Lattner 6927e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 6937e70829632f82de15db187845666aaca6e04b792Chris Lattner int Slot = Table.getValSlot(&V); // Print out the def slot taken... 694e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (Slot >= 0) Out << ":" << Slot; 695e02fa8551d20081534afa46e0976811687e5183aChris Lattner else Out << ":<badref>"; 696e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 6977e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << " [#uses=" << V.use_size() << "]"; // Output # uses 698e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 699e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 700e02fa8551d20081534afa46e0976811687e5183aChris Lattner 701c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printInstruction - This member is called for each Instruction in a methd. 702009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 7037e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 704009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\t"; 705009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 706009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 7077e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 7087e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << "%" << I.getName() << " = "; 709009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 710009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 7117e70829632f82de15db187845666aaca6e04b792Chris Lattner Out << I.getOpcodeName(); 712009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 713009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 7147e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 715009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 716009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 7177e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 7187e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 719009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 720009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 721009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 7227e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 723009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 72494dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 725009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 7267e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(Operand , true); Out << ","; 7277e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); Out << " ["; 728009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7297e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 730009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t\t"; 7317e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op ), true); Out << ","; 7327e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 733009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 734009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t]"; 735b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 736c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 7377e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 738eed1fc79735c3ade3dddc0d45eec2c9811969e21Chris Lattner Out << " "; 739009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7407e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 7418f410cac044a21a94afece41345ccd9b72047675Chris Lattner if (op) Out << ", "; 7428f410cac044a21a94afece41345ccd9b72047675Chris Lattner Out << "["; 7437e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op ), false); Out << ","; 7447e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), false); Out << " ]"; 745c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 746e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 747009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " void"; 748e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 749268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner const PointerType *PTy = dyn_cast<PointerType>(Operand->getType()); 7506bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner const FunctionType*MTy = PTy ? dyn_cast<FunctionType>(PTy->getElementType()):0; 751268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner const Type *RetTy = MTy ? MTy->getReturnType() : 0; 752268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 753268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // If possible, print out the short form of the call instruction, but we can 754b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 755b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // and if the value returned is not a pointer to a function. 756268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 75794dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (RetTy && MTy && !MTy->isVarArg() && 75894dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner (!isa<PointerType>(RetTy) || 759c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 760268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner Out << " "; printType(RetTy); 761268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 762268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 763268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 764268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 765009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "("; 7667e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 7677e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 768009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 7697e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 770009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 771009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 772009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " )"; 7737e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 774e02fa8551d20081534afa46e0976811687e5183aChris Lattner // TODO: Should try to print out short form of the Invoke instruction 775e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(Operand, true); 776e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << "("; 7777e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 7787e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 779e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << ","; 7807e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 781e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 782e02fa8551d20081534afa46e0976811687e5183aChris Lattner 783e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " )\n\t\t\tto"; 784e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 785e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " except"; 786e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getExceptionalDest(), true); 787e02fa8551d20081534afa46e0976811687e5183aChris Lattner 7887e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 789c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 79094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 79194dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 792c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner Out << ","; 79394dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 794009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 795e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 79668e0278815836ca414ceb9b6087bf3cdc051947aChris Lattner if (Operand) writeOperand(Operand, true); 797c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " to "; 7987e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 799009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 800009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 801009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 802009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 803009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 804009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 805009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 806009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 807ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner // Shift Left & Right print both types even for Ubyte LHS 808ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (isa<ShiftInst>(I)) { 809ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 810ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 811ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 812ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 813ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 814ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 815ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 816ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 817009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 818009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 819ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner 820c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 821c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 822ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 823c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 824009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8257e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 826009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (i) Out << ","; 8277e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 828009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 829009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 830009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 831e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 832697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 833009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 834009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 835009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 836009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 837009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 838009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 839009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 840009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 84175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Module::print(std::ostream &o) const { 84275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(this, true); 84375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, this); 84475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 845009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 846009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 84775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 84875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 84975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, getParent()); 85075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 851b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 852b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 85375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Function::print(std::ostream &o) const { 85475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 85575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, getParent()); 856009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 85775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 858009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 859009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 86075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid BasicBlock::print(std::ostream &o) const { 86175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(getParent(), true); 86275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, 86375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner getParent() ? getParent()->getParent() : 0); 86475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 86575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 866009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 86775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Instruction::print(std::ostream &o) const { 86875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 86975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner SlotCalculator SlotTable(F, true); 87075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0); 871009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 87275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 87375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 874009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 87575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 87675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 8773bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 8783bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner // Handle CPR's special, because they have context information... 8793bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { 8803bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner CPR->getValue()->print(o); // Print as a global value, with context info. 8813bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner return; 8823bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner } 8833bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 88466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner o << " " << getType()->getDescription() << " "; 88566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 88666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner map<const Type *, string> TypeTable; 88766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner WriteConstantInt(o, this, false, TypeTable, 0); 888009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 889009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 89075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Type::print(std::ostream &o) const { 89175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 89275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 89375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 89475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 895009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 896009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 89773e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 89875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getType() << " " << getName(); 89975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 900009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 90175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Value::dump() const { print(std::cerr); } 902009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 90375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 90475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 90575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 906da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 907da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 908da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 909da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 910da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = new SlotCalculator(M, true); 911da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner AW = new AssemblyWriter(Out, *SC, M); 912da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 913da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 914da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 915da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 916da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 917da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 918da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 919da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 920da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 921da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 922da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter &CachedWriter::operator<<(const Value *V) { 923da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 924da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner switch (V->getValueType()) { 925da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ConstantVal: 92666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner case Value::ArgumentVal: AW->writeOperand(V, true, true); break; 927da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::TypeVal: AW->write(cast<const Type>(V)); break; 928da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 929da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 93079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionVal: AW->write(cast<Function>(V)); break; 931da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 932da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner default: Out << "<unknown value type: " << V->getValueType() << ">"; break; 933da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 934da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 935da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 936