AsmWriter.cpp revision 79df7c0aaa18129e55968c8783ef8346807bd4af
1009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===-- Writer.cpp - Library for Printing VM assembly files ------*- C++ -*--=// 2009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 3009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 4009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 5009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library uses the Analysis library to figure out offsets for 6009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// variables in the method tables... 7009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 8009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// TODO: print out the type name instead of the full type if a particular type 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// is in the symbol table... 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 12009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 13da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 14009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/Analysis/SlotCalculator.h" 15009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/Module.h" 1679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner#include "llvm/Function.h" 1770cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner#include "llvm/GlobalVariable.h" 18009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/BasicBlock.h" 19e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner#include "llvm/ConstantVals.h" 20009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 21e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 227061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 237061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 24007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 25cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 26cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 27007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 28c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner#include <map> 29697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::string; 30697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::map; 31697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::vector; 32697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::ostream; 33c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 34207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 3579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (const FunctionArgument *MA = dyn_cast<const FunctionArgument>(V)) 36207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 37207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V)) 38207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 39207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner else if (const Instruction *I = dyn_cast<const Instruction>(V)) { 4079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 41207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 4279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const GlobalValue *GV = dyn_cast<const GlobalValue>(V)) 43207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 44207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner else if (const Module *Mod = dyn_cast<const Module>(V)) 45207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Mod; 46207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 47207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 48207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 49c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnerstatic SlotCalculator *createSlotCalculator(const Value *V) { 50c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner assert(!isa<Type>(V) && "Can't create an SC for a type!"); 5179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (const FunctionArgument *FA = dyn_cast<const FunctionArgument>(V)) { 5279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(FA->getParent(), true); 53c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } else if (const Instruction *I = dyn_cast<const Instruction>(V)) { 54c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(I->getParent()->getParent(), true); 55c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } else if (const BasicBlock *BB = dyn_cast<const BasicBlock>(V)) { 56c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(BB->getParent(), true); 5779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const GlobalVariable *GV = dyn_cast<const GlobalVariable>(V)){ 58c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(GV->getParent(), true); 5979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner } else if (const Function *Func = dyn_cast<const Function>(V)) { 6079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return new SlotCalculator(Func, true); 61c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } else if (const Module *Mod = dyn_cast<const Module>(V)) { 62c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return new SlotCalculator(Mod, true); 63c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 64c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 65c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 66009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 67622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 68622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 69622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner// whole instruction that generated it. 70622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner// 71207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, 72207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner SlotCalculator *Table) { 73007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (PrintName && V->hasName()) { 74622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner Out << " %" << V->getName(); 75622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } else { 76e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner if (const Constant *CPV = dyn_cast<const Constant>(V)) { 77622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner Out << " " << CPV->getStrValue(); 78622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } else { 79622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner int Slot; 80622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner if (Table) { 81622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner Slot = Table->getValSlot(V); 82622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } else { 83207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (const Type *Ty = dyn_cast<const Type>(V)) { 84207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " " << Ty->getDescription(); 85207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return; 86207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 87c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 88c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Table = createSlotCalculator(V); 89207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } 90c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 91622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner Slot = Table->getValSlot(V); 92622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner delete Table; 93622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } 94622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner if (Slot >= 0) Out << " %" << Slot; 95622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner else if (PrintName) 96622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner Out << "<badref>"; // Not embeded into a location? 97622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } 98622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner } 99207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 100207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 101207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 102207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// If the module has a symbol table, take all global types and stuff their 103207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// names into the TypeNames map. 104207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 105207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 106207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 107207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (M && M->hasSymbolTable()) { 108207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const SymbolTable *ST = M->getSymbolTable(); 109207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner SymbolTable::const_iterator PI = ST->find(Type::TypeTy); 110207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (PI != ST->end()) { 111207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner SymbolTable::type_const_iterator I = PI->second.begin(); 112207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner for (; I != PI->second.end(); ++I) { 113207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // As a heuristic, don't insert pointer to primitive types, because 114207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they are used too often to have a single useful name. 115207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 116207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const Type *Ty = cast<const Type>(I->second); 117207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (!isa<PointerType>(Ty) || 1187a1767520611d9ff6face702068de858e1cadf2cChris Lattner !cast<PointerType>(Ty)->getElementType()->isPrimitiveType()) 119697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, "%"+I->first)); 120207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 121207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 122207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 123207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 124207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 125207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 126207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 127207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic string calcTypeName(const Type *Ty, vector<const Type *> &TypeStack, 128207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 129207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Ty->getDescription(); // Base case 130207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 131207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 132207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string>::iterator I = TypeNames.find(Ty); 133207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return I->second; 134207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 135207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 136207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 137207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 138207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 139207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 140207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 141207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 142207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 143207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Slot < CurSize) 144207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return "\\" + utostr(CurSize-Slot); // Here's the upreference 145207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 146207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 147207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 148207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner string Result; 149207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner switch (Ty->getPrimitiveID()) { 150207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::MethodTyID: { 151207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const MethodType *MTy = cast<const MethodType>(Ty); 152207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = calcTypeName(MTy->getReturnType(), TypeStack, TypeNames) + " ("; 153207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner for (MethodType::ParamTypes::const_iterator 154207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner I = MTy->getParamTypes().begin(), 155207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner E = MTy->getParamTypes().end(); I != E; ++I) { 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != MTy->getParamTypes().begin()) 157207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 158207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 160207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (MTy->isVarArg()) { 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (!MTy->getParamTypes().empty()) Result += ", "; 162207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 163207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 165207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 166207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 167207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 168207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const StructType *STy = cast<const StructType>(Ty); 169207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "{ "; 170207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner for (StructType::ElementTypes::const_iterator 171207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner I = STy->getElementTypes().begin(), 172207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner E = STy->getElementTypes().end(); I != E; ++I) { 173207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != STy->getElementTypes().begin()) 174207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 175207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 176207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 177207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 178207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 179207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 180207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 1817a1767520611d9ff6face702068de858e1cadf2cChris Lattner Result = calcTypeName(cast<const PointerType>(Ty)->getElementType(), 182207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack, TypeNames) + " *"; 183207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 184207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner const ArrayType *ATy = cast<const ArrayType>(Ty); 186207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner int NumElements = ATy->getNumElements(); 187207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "["; 188207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (NumElements != -1) Result += itostr(NumElements) + " x "; 189207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 190207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 191207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 192207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 193207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner assert(0 && "Unhandled case in getTypeProps!"); 194207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "<error>"; 195207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 196207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 197207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 198207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Result; 199207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 200207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 201207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 202207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// printTypeInt - The internal guts of printing out a type that has a 203207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// potentially named portion. 204207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 205207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic ostream &printTypeInt(ostream &Out, const Type *Ty, 206207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> &TypeNames) { 207207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 208207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 209207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 210207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Ty->isPrimitiveType()) return Out << Ty->getDescription(); 211207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 212207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 213207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string>::iterator I = TypeNames.find(Ty); 214207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 215207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 216207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 217207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 218207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 219207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 220207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner vector<const Type *> TypeStack; 221207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 222697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 223207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Out << TypeName; 224207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 225207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 226e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 227207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 228207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type, iff there is an entry in the modules symbol table for the specified 229207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// type or one of it's component types. This is slower than a simple x << Type; 230207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 231207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerostream &WriteTypeSymbolic(ostream &Out, const Type *Ty, const Module *M) { 232207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " "; 233207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 234207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 235207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 236207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (M && M->hasSymbolTable()) { 237207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner map<const Type *, string> TypeNames; 238207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 239207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2407b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 241207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 2427b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 243207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 244207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 245207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 246207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 247207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// WriteAsOperand - Write the name of the specified value out to the specified 248207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// ostream. This can be useful when you just want to print int %reg126, not the 249207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// whole instruction that generated it. 250207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner// 251207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerostream &WriteAsOperand(ostream &Out, const Value *V, bool PrintType, 252207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner bool PrintName, SlotCalculator *Table) { 2537b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner if (PrintType) 2547b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner WriteTypeSymbolic(Out, V->getType(), getModuleFromVal(V)); 255207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 256207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner WriteAsOperandInternal(Out, V, PrintName, Table); 257622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 258622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 259622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 260622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 261d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 262007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 263009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner ostream &Out; 264009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator &Table; 265c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 266c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner map<const Type *, string> TypeNames; 267009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 268c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline AssemblyWriter(ostream &o, SlotCalculator &Tab, const Module *M) 269c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner : Out(o), Table(Tab), TheModule(M) { 270c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 271c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 272c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 273c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 274207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 275009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 276009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 277c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 278c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 27979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 280c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 281c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Instruction *I) { printInstruction(I); } 282e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 283da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 284009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 285009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 286c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 287c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 288e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 289c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 29079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 29179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunctionArgument(const FunctionArgument *FA); 292c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 293c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printInstruction(const Instruction *I); 294c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner ostream &printType(const Type *Ty); 295c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 296009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 297e02fa8551d20081534afa46e0976811687e5183aChris Lattner 298e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 299e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 300e02fa8551d20081534afa46e0976811687e5183aChris Lattner void printInfoComment(const Value *V); 301009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 302009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 303009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 304007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 305007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner bool PrintName) { 306c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (PrintType) { Out << " "; printType(Operand->getType()); } 307207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner WriteAsOperandInternal(Out, Operand, PrintName, &Table); 308007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 309007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 310007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 311c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 312007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 313007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (M->hasSymbolTable()) 314c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printSymbolTable(*M->getSymbolTable()); 31570cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 31670cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner for_each(M->gbegin(), M->gend(), 317c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner bind_obj(this, &AssemblyWriter::printGlobal)); 318007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 3195efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve Out << "implementation\n"; 3205efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 321007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the methods... 32279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for_each(M->begin(), M->end(), bind_obj(this,&AssemblyWriter::printFunction)); 323009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 324009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 325c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 32670cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner if (GV->hasName()) Out << "%" << GV->getName() << " = "; 327d70684f7585a85c4248c1c224059478108741c70Chris Lattner 328dda719665ba2ffd2eb1c32a0d2daa3921448db7cChris Lattner if (GV->hasInternalLinkage()) Out << "internal "; 329d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (!GV->hasInitializer()) Out << "uninitialized "; 330d70684f7585a85c4248c1c224059478108741c70Chris Lattner 331c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << (GV->isConstant() ? "constant " : "global "); 3327a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 333d70684f7585a85c4248c1c224059478108741c70Chris Lattner 334d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (GV->hasInitializer()) 335d70684f7585a85c4248c1c224059478108741c70Chris Lattner writeOperand(GV->getInitializer(), false, false); 336d70684f7585a85c4248c1c224059478108741c70Chris Lattner 337e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(GV); 338697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 33970cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 34070cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 341009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 342c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printSymbolTable - Run through symbol table looking for named constants 343007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// if a named constant is found, emit it's declaration... 344007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner// 345c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 346007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) { 347007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator I = ST.type_begin(TI->first); 348007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator End = ST.type_end(TI->first); 349007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 350007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (; I != End; ++I) { 351007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner const Value *V = I->second; 352e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner if (const Constant *CPV = dyn_cast<const Constant>(V)) { 353c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printConstant(CPV); 3541d87bcf4909b06dcd86320722653341f08b8b396Chris Lattner } else if (const Type *Ty = dyn_cast<const Type>(V)) { 355697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\t%" << I->first << " = type " << Ty->getDescription() << "\n"; 356007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 357007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 358739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 359009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 360009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 361009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 362c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printConstant - Print out a constant pool entry... 363009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 364e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 365007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 366007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 367009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 3681333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 3691333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner Out << "\t%" << CPV->getName() << " = "; 370009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 3711333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out the constant type... 372c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(CPV->getType()); 373009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 374009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 375009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(CPV, false, false); 376009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 377009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (!CPV->hasName() && CPV->getType() != Type::VoidTy) { 378009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner int Slot = Table.getValSlot(CPV); // Print out the def slot taken... 379c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << "\t\t; <"; 380c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(CPV->getType()) << ">:"; 381009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Slot >= 0) Out << Slot; 382009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else Out << "<badref>"; 383009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 384009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 385697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 386009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 387009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 38879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// printFunction - Print all aspects of a method. 389009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 39079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnervoid AssemblyWriter::printFunction(const Function *M) { 391009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 392dda719665ba2ffd2eb1c32a0d2daa3921448db7cChris Lattner Out << "\n" << (M->isExternal() ? "declare " : "") 393dda719665ba2ffd2eb1c32a0d2daa3921448db7cChris Lattner << (M->hasInternalLinkage() ? "internal " : ""); 394c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(M->getReturnType()) << " \"" << M->getName() << "\"("; 395009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Table.incorporateMethod(M); 396007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 397c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 398e02fa8551d20081534afa46e0976811687e5183aChris Lattner const MethodType *MT = cast<const MethodType>(M->getMethodType()); 399007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 400e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (!M->isExternal()) { 401e02fa8551d20081534afa46e0976811687e5183aChris Lattner for_each(M->getArgumentList().begin(), M->getArgumentList().end(), 40279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner bind_obj(this, &AssemblyWriter::printFunctionArgument)); 403e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else { 404c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 405e02fa8551d20081534afa46e0976811687e5183aChris Lattner const MethodType *MT = cast<const MethodType>(M->getMethodType()); 406e02fa8551d20081534afa46e0976811687e5183aChris Lattner for (MethodType::ParamTypes::const_iterator I = MT->getParamTypes().begin(), 407e02fa8551d20081534afa46e0976811687e5183aChris Lattner E = MT->getParamTypes().end(); I != E; ++I) { 408e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (I != MT->getParamTypes().begin()) Out << ", "; 409c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(*I); 410e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 411e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 412007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 413007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 414007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (MT->isVarArg()) { 415007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (MT->getParamTypes().size()) Out << ", "; 416007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Out << "..."; // Output varargs portion of signature! 417007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 418007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Out << ")\n"; 419007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 420007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!M->isExternal()) { 421007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 422007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (M->hasSymbolTable()) 423c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printSymbolTable(*M->getSymbolTable()); 424007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 425007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Out << "begin"; 426007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 427007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of its basic blocks... for the method 428007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for_each(M->begin(), M->end(), 429c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner bind_obj(this, &AssemblyWriter::printBasicBlock)); 430007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 431739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner Out << "end\n"; 432007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 433007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 434007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner Table.purgeMethod(); 435009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 436009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 43779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// printFunctionArgument - This member is called for every argument that 438009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// is passed into the method. Simply print it out 439009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 44079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnervoid AssemblyWriter::printFunctionArgument(const FunctionArgument *Arg) { 441009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 442009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", "; 443009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 444009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 445c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 446009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 447009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 448009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 449009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " %" << Arg->getName(); 450009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else if (Table.getValSlot(Arg) < 0) 451009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "<badref>"; 452009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 453009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 454c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printBasicBlock - This member is called for each basic block in a methd. 455009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 456c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 457009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 458b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "\n" << BB->getName() << ":"; 459009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else { 460009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner int Slot = Table.getValSlot(BB); 461b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "\n; <label>:"; 462009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Slot >= 0) 463b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << Slot; // Extra newline seperates out label's 464009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else 465b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "<badref>"; 466009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 467b9a4578df5e240d2e2e5d3f1f538188a054d70b4Chris Lattner Out << "\t\t\t\t\t;[#uses=" << BB->use_size() << "]\n"; // Output # uses 468009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 469007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 470007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for_each(BB->begin(), BB->end(), 471c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner bind_obj(this, &AssemblyWriter::printInstruction)); 472009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 473009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 474e02fa8551d20081534afa46e0976811687e5183aChris Lattner 475e02fa8551d20081534afa46e0976811687e5183aChris Lattner// printInfoComment - Print a little comment after the instruction indicating 476e02fa8551d20081534afa46e0976811687e5183aChris Lattner// which slot it occupies. 477e02fa8551d20081534afa46e0976811687e5183aChris Lattner// 478e02fa8551d20081534afa46e0976811687e5183aChris Lattnervoid AssemblyWriter::printInfoComment(const Value *V) { 479e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (V->getType() != Type::VoidTy) { 480c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << "\t\t; <"; 481c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(V->getType()) << ">"; 482e02fa8551d20081534afa46e0976811687e5183aChris Lattner 483e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (!V->hasName()) { 484e02fa8551d20081534afa46e0976811687e5183aChris Lattner int Slot = Table.getValSlot(V); // Print out the def slot taken... 485e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (Slot >= 0) Out << ":" << Slot; 486e02fa8551d20081534afa46e0976811687e5183aChris Lattner else Out << ":<badref>"; 487e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 488f7a551fd929a4a849883cde04cfe54e0590a38b7Chris Lattner Out << " [#uses=" << V->use_size() << "]"; // Output # uses 489e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 490e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 491e02fa8551d20081534afa46e0976811687e5183aChris Lattner 492c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printInstruction - This member is called for each Instruction in a methd. 493009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 494c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction *I) { 495009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\t"; 496009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 497009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 498009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (I && I->hasName()) 499009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "%" << I->getName() << " = "; 500009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 501009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 502a41f50dea8573e4a610b5aa5e45b5c368559b084Chris Lattner Out << I->getOpcodeName(); 503009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 504009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 505c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner const Value *Operand = I->getNumOperands() ? I->getOperand(0) : 0; 506009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 507009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 508a41f50dea8573e4a610b5aa5e45b5c368559b084Chris Lattner if (I->getOpcode() == Instruction::Br && I->getNumOperands() > 1) { 509009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(I->getOperand(2), true); 510009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 511009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 512009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 513009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(I->getOperand(1), true); 514009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 515a41f50dea8573e4a610b5aa5e45b5c368559b084Chris Lattner } else if (I->getOpcode() == Instruction::Switch) { 516009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 517009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand , true); Out << ","; 518009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(I->getOperand(1), true); Out << " ["; 519009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 520c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; op += 2) { 521009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t\t"; 522c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner writeOperand(I->getOperand(op ), true); Out << ","; 523009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(I->getOperand(op+1), true); 524009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 525009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "\n\t]"; 526b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 527c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 5288f410cac044a21a94afece41345ccd9b72047675Chris Lattner printType(I->getType()); 529eed1fc79735c3ade3dddc0d45eec2c9811969e21Chris Lattner Out << " "; 530009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 5318f410cac044a21a94afece41345ccd9b72047675Chris Lattner for (unsigned op = 0, Eop = I->getNumOperands(); op < Eop; op += 2) { 5328f410cac044a21a94afece41345ccd9b72047675Chris Lattner if (op) Out << ", "; 5338f410cac044a21a94afece41345ccd9b72047675Chris Lattner Out << "["; 534c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner writeOperand(I->getOperand(op ), false); Out << ","; 53528d480b31623371e9d738d17a62dd0bd6cdce1cdChris Lattner writeOperand(I->getOperand(op+1), false); Out << " ]"; 536c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 537e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 538009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " void"; 539e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 540268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner const PointerType *PTy = dyn_cast<PointerType>(Operand->getType()); 5417a1767520611d9ff6face702068de858e1cadf2cChris Lattner const MethodType *MTy = PTy ?dyn_cast<MethodType>(PTy->getElementType()):0; 542268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner const Type *RetTy = MTy ? MTy->getReturnType() : 0; 543268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 544268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // If possible, print out the short form of the call instruction, but we can 545268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // only do this if the first argument is a pointer to a nonvararg method, 546268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // and if the value returned is not a pointer to a method. 547268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 548268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner if (RetTy && !MTy->isVarArg() && 549268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner (!isa<PointerType>(RetTy)||!isa<MethodType>(cast<PointerType>(RetTy)))){ 550268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner Out << " "; printType(RetTy); 551268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 552268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 553268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 554268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 555009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << "("; 556c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner if (I->getNumOperands() > 1) writeOperand(I->getOperand(1), true); 557c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; ++op) { 558009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << ","; 559c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner writeOperand(I->getOperand(op), true); 560009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 561009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 562009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner Out << " )"; 563e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) { 564e02fa8551d20081534afa46e0976811687e5183aChris Lattner // TODO: Should try to print out short form of the Invoke instruction 565e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(Operand, true); 566e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << "("; 567e02fa8551d20081534afa46e0976811687e5183aChris Lattner if (I->getNumOperands() > 3) writeOperand(I->getOperand(3), true); 568e02fa8551d20081534afa46e0976811687e5183aChris Lattner for (unsigned op = 4, Eop = I->getNumOperands(); op < Eop; ++op) { 569e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << ","; 570e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(I->getOperand(op), true); 571e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 572e02fa8551d20081534afa46e0976811687e5183aChris Lattner 573e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " )\n\t\t\tto"; 574e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 575e02fa8551d20081534afa46e0976811687e5183aChris Lattner Out << " except"; 576e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getExceptionalDest(), true); 577e02fa8551d20081534afa46e0976811687e5183aChris Lattner 578a41f50dea8573e4a610b5aa5e45b5c368559b084Chris Lattner } else if (I->getOpcode() == Instruction::Malloc || 579a41f50dea8573e4a610b5aa5e45b5c368559b084Chris Lattner I->getOpcode() == Instruction::Alloca) { 580c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 5817a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(cast<const PointerType>(I->getType())->getElementType()); 582c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner if (I->getNumOperands()) { 583c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner Out << ","; 584c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner writeOperand(I->getOperand(0), true); 585009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 586e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 5870908309e3c4b4f423e88d8d8fe8060cb10eaa1c9Chris Lattner writeOperand(Operand, true); 588c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " to "; 589c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(I->getType()); 590009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 591009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 592009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 593009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 594009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 595009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 596009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 597009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 598c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner for (unsigned i = 1, E = I->getNumOperands(); i != E; ++i) { 599c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner Operand = I->getOperand(i); 600009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Operand->getType() != TheType) { 601009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 602009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner break; 603009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 604009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 605009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 606f434cd1b30a77afa26de46a3e7afb8a07b536c6fChris Lattner // Shift Left & Right print both types even for Ubyte LHS 607f434cd1b30a77afa26de46a3e7afb8a07b536c6fChris Lattner if (isa<ShiftInst>(I)) PrintAllTypes = true; 608f434cd1b30a77afa26de46a3e7afb8a07b536c6fChris Lattner 609c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 610c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner Out << " "; 611c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(I->getOperand(0)->getType()); 612c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 613009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 614c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner for (unsigned i = 0, E = I->getNumOperands(); i != E; ++i) { 615009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (i) Out << ","; 616c8b25d40cbec063b1ca99cc1adf794399c6d05c0Chris Lattner writeOperand(I->getOperand(i), PrintAllTypes); 617009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 618009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 619009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 620e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 621697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner Out << "\n"; 622009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 623009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 624009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 625c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// printType - Go to extreme measures to attempt to print out a short, symbolic 626c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// version of a type name. 627c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner// 628c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnerostream &AssemblyWriter::printType(const Type *Ty) { 629207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return printTypeInt(Out, Ty, TypeNames); 630c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 631c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 632c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 633009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 634009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 635009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 636009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 637009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 638009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 639009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnervoid WriteToAssembly(const Module *M, ostream &o) { 640009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (M == 0) { o << "<null> module\n"; return; } 641009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator SlotTable(M, true); 642c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner AssemblyWriter W(o, SlotTable, M); 643009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 644009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner W.write(M); 645009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 646009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 647b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattnervoid WriteToAssembly(const GlobalVariable *G, ostream &o) { 648b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner if (G == 0) { o << "<null> global variable\n"; return; } 649b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner SlotCalculator SlotTable(G->getParent(), true); 650c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner AssemblyWriter W(o, SlotTable, G->getParent()); 651b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner W.write(G); 652b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 653b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 65479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnervoid WriteToAssembly(const Function *F, ostream &o) { 65579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (F == 0) { o << "<null> function\n"; return; } 65679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SlotCalculator SlotTable(F->getParent(), true); 65779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner AssemblyWriter W(o, SlotTable, F->getParent()); 658009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 65979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner W.write(F); 660009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 661009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 662009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 663009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnervoid WriteToAssembly(const BasicBlock *BB, ostream &o) { 664009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB == 0) { o << "<null> basic block\n"; return; } 665009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 666009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator SlotTable(BB->getParent(), true); 667c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner AssemblyWriter W(o, SlotTable, 668c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner BB->getParent() ? BB->getParent()->getParent() : 0); 669009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 670009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner W.write(BB); 671009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 672009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 673e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid WriteToAssembly(const Constant *CPV, ostream &o) { 674009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (CPV == 0) { o << "<null> constant pool value\n"; return; } 675c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner o << " " << CPV->getType()->getDescription() << " " << CPV->getStrValue(); 676009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 677009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 678009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnervoid WriteToAssembly(const Instruction *I, ostream &o) { 679009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (I == 0) { o << "<null> instruction\n"; return; } 680009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 68179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *F = I->getParent() ? I->getParent()->getParent() : 0; 68279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SlotCalculator SlotTable(F, true); 68379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0); 684009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 685009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner W.write(I); 686009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 687da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 688da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 689da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 690da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 691da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = new SlotCalculator(M, true); 692da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner AW = new AssemblyWriter(Out, *SC, M); 693da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 694da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 695da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 696da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 697da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 698da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 699da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 700da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 701da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 702da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 703da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter &CachedWriter::operator<<(const Value *V) { 704da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 705da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner switch (V->getValueType()) { 706da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ConstantVal: 707da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner Out << " "; AW->write(V->getType()); 708e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Out << " " << cast<Constant>(V)->getStrValue(); break; 70979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionArgumentVal: 710da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner AW->write(V->getType()); Out << " " << V->getName(); break; 711da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::TypeVal: AW->write(cast<const Type>(V)); break; 712da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 713da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 71479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionVal: AW->write(cast<Function>(V)); break; 715da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 716da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ModuleVal: AW->write(cast<Module>(V)); break; 717da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner default: Out << "<unknown value type: " << V->getValueType() << ">"; break; 718da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 719da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 720da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 721