AsmWriter.cpp revision e5242def97c52077b4e0a77a501f324867f7bce5
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 1202b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// Note that these routines must be extremely tolerant of various errors in the 138f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner// LLVM code, because it can be used for debugging transformations. 1402b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 15009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 16009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 17da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 1875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 19f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 2095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner#include "llvm/Assembly/AsmAnnotationWriter.h" 21f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Constants.h" 223eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 23b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 24009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 25e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 267061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 277061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 28f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Module.h" 29007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 305cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman#include "llvm/Analysis/SlotCalculator.h" 315cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman#include "llvm/Assembly/Writer.h" 32061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner#include "llvm/Support/CFG.h" 33cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 34cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 35007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 3631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 37d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 38a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintModulePass> 39a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerX("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 40a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintFunctionPass> 41a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerY("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 42f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 437b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 447b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 457b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 467a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table); 477a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 48207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 49949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 50207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 51949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 52207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 53949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 5479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 55207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 56949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 57207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 58207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 59207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 60207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 61c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnerstatic SlotCalculator *createSlotCalculator(const Value *V) { 62c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner assert(!isa<Type>(V) && "Can't create an SC for a type!"); 63949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 648ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner return new SlotCalculator(FA->getParent(), false); 65949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 668ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner return new SlotCalculator(I->getParent()->getParent(), false); 67949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 688ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner return new SlotCalculator(BB->getParent(), false); 69949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 708ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner return new SlotCalculator(GV->getParent(), false); 71949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 728ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner return new SlotCalculator(Func, false); 73c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 74c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 75c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 76009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 7824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 7924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 8024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattnerstatic std::string getLLVMName(const std::string &Name) { 8124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 8224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 8324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 8424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 8524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 8624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 8724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 8824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 8924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 9024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 9124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 9224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 9324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 9424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 9524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 9624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 9724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "%"+Name; 9824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 9924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 100207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 101ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 102ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 103ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 104207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 1057b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 1066e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 1076e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 1086e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::const_iterator PI = ST.find(Type::TypeTy); 1096e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (PI != ST.end()) { 1106e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable::type_const_iterator I = PI->second.begin(); 1116e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner for (; I != PI->second.end(); ++I) { 1126e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // As a heuristic, don't insert pointer to primitive types, because 1136e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // they are used too often to have a single useful name. 1146e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner // 115949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const Type *Ty = cast<Type>(I->second); 1166e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!isa<PointerType>(Ty) || 11788c17380646dbb7c0c5054a392de5a46d17620baChris Lattner !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 11888c17380646dbb7c0c5054a392de5a46d17620baChris Lattner isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 11924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner TypeNames.insert(std::make_pair(Ty, getLLVMName(I->first))); 120207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 121207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 122207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 123207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 124207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 125207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1267b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::string calcTypeName(const Type *Ty, 1277b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> &TypeStack, 1287b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames){ 12988c17380646dbb7c0c5054a392de5a46d17620baChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 13088c17380646dbb7c0c5054a392de5a46d17620baChris Lattner return Ty->getDescription(); // Base case 131207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 132207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 1337b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 134207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return I->second; 135207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 13688c17380646dbb7c0c5054a392de5a46d17620baChris Lattner if (isa<OpaqueType>(Ty)) 13788c17380646dbb7c0c5054a392de5a46d17620baChris Lattner return "opaque"; 13888c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 139207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 140207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 141207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 142207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 143207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 144207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 145207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 146207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Slot < CurSize) 147207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return "\\" + utostr(CurSize-Slot); // Here's the upreference 148207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 149207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 150207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1517b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string Result; 152207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner switch (Ty->getPrimitiveID()) { 1536bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 154949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 1552761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; 156d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 157d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 158d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 160207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 1622761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 163d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 165207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 166207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 167207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 168207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 169207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 170949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 171207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "{ "; 172d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 173d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 174d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 175207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 176207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 177207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 178207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 179207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 180207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 181207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 182949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner Result = calcTypeName(cast<PointerType>(Ty)->getElementType(), 18302b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner TypeStack, TypeNames) + "*"; 184207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 186949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 187ff5c296498b3b1182e8d5e2515d0c15a7b558d4bChris Lattner Result = "[" + utostr(ATy->getNumElements()) + " x "; 188207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 189207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 190207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 1919e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 1929e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner Result = "opaque"; 1939e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 194207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 195b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Result = "<unrecognized-type>"; 196207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 197207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 198207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 199207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Result; 200207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 201207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 202207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2039d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 2049d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 2059d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 2067b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 2077b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 208207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 209207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 210207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 211daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 212daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 213207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 214207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2157b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 216207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 217207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 218207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 219207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 220207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 221207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 2227b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 2237b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 224697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 225207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Out << TypeName; 226207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 227207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 228e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 2299d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 2309d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 2319d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 2329d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 23331f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 23431f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 235207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " "; 236207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 237207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 238207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 2396e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 2407b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 241207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 242207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2437b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 244207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 2457b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 246207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 247207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 248207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2497b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 2507b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 2517b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 2527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 25366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 25466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << (CB == ConstantBool::True ? "true" : "false"); 25566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 25666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 25766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 25866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 25966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 26066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 26166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 26266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 26366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 26466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 26566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 26666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 26766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 26866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 26966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 27066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 27166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 27266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 273b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 27466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 27566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 27666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << StrVal; return; 27766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 27866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 27966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 28066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 28166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 28266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Behave nicely in the face of C TBAA rules... see: 28366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // http://www.nullstone.com/htmls/category/aliastyp.htm 28466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 28566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner double Val = CFP->getValue(); 28666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner char *Ptr = (char*)&Val; 28766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 28866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 28966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "0x" << utohexstr(*(uint64_t*)Ptr); 29066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 291de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 292de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 29366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 29466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 29566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 29666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 29766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 29866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 29966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 30066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (ETy == Type::SByteTy) 30166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) 30266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 30366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner isString = false; 30466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner break; 30566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 30666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 30766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (isString) { 30866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 30966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 310c07736a397012499e337c994f7f952b07c709544Chris Lattner unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue(); 31166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 312fc94446777fcdff03fdc09539bab25200936b43eChris Lattner if (isprint(C) && C != '"' && C != '\\') { 31366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << C; 31466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 31566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << '\\' 31666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 31766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 31866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 31966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 32066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 32166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 32266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 3237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "["; 3247a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 3257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 32666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 3277a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 3287a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3297a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 3307a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 33166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 3327a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 3337a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner TypeTable, Table); 3347a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 3377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 3397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "{"; 3407a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CS->getNumOperands()) { 3417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 3427a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 3437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 3457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3467a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3477a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1; i < CS->getNumOperands(); i++) { 3487a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 3497a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 3507a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 3527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner PrintName, TypeTable, Table); 3537a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3547a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3557a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3567a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 3577a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 3587a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 3597a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3607e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { 3612ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner WriteAsOperandInternal(Out, PR->getValue(), true, TypeTable, Table); 362b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 363c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 36438d877365030f90b099d53ab6a66bd62271e330fChris Lattner Out << CE->getOpcodeName() << " ("; 365b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 366b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 367b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 368b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table); 369b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 370c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 371b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 372b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 3731c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner if (CE->getOpcode() == Instruction::Cast) { 37495586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 37595586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 37695586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 3771c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner Out << ")"; 37895586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 3797a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 380b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 3817a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 3827a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 3837a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 3847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 385ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 386ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 387ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 388ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 3897b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 3907b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 3917b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 3927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner SlotCalculator *Table) { 3937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 3947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintName && V->hasName()) { 39524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 3967a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 397949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CV = dyn_cast<Constant>(V)) { 3987a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteConstantInt(Out, CV, PrintName, TypeTable, Table); 3997a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 4007a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 4017a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table) { 40260596382aa6d2f54949684a07f5ab0ab881896d7Alkis Evlogimenos Slot = Table->getSlot(V); 4037a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 404949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Type *Ty = dyn_cast<Type>(V)) { 4057a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << Ty->getDescription(); 4067a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner return; 4077a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Table = createSlotCalculator(V); 4107a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } 4117a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 41260596382aa6d2f54949684a07f5ab0ab881896d7Alkis Evlogimenos Slot = Table->getSlot(V); 4137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner delete Table; 4147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (Slot >= 0) Out << "%" << Slot; 4167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner else if (PrintName) 4179d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman if (V->hasName()) 4189d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman Out << "<badref: " << getLLVMName(V->getName()) << ">"; 4199d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman else 4209d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman Out << "<badref>"; // Not embedded into a location? 4217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4227a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 4247a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4269d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 4279d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 4289d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 4299d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 43031f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 4319d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman bool PrintType, bool PrintName, 4329d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman const Module *Context) { 4337b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 434607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 4357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4366e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 437607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 438207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 4397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 4407a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 4417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 442cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke if (const Type *Ty = dyn_cast<Type> (V)) 443cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke printTypeInt(Out, Ty, TypeNames); 444cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke 445607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 446622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 447622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 448622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 44931f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 450d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 451007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 452e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman std::ostream *Out; 453009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner SlotCalculator &Table; 454c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 4557b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 45695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 457009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 45895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner inline AssemblyWriter(std::ostream &o, SlotCalculator &Tab, const Module *M, 45995e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 460e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman : Out(&o), Table(Tab), TheModule(M), AnnotationWriter(AAW) { 461c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 462c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 463c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 464c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 465207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 466009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 467009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 468c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 469c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 47079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 471c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 4727e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 473e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 474da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 475009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 47666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 47766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 4785cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 479e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman void setStream(std::ostream &os) { Out = &os; } 4805cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 481009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 482c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 483c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 484e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 485c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 48679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 48773e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 488c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 4897e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 4902761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4912761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 4922761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 4932761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 4947b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 495e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman return printTypeInt(*Out, Ty, TypeNames); 4962761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 4972761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 4982761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 4992761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 5002761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 5017b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 502c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 503e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 504e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 5057e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 506009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 50731f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner} // end of anonymous namespace 508009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 509ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 510ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 511ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 5127b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 5137e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 5142761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 515d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 516d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 517d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 518e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 5197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 5202761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5212761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 522e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (FTy->getNumParams()) *Out << ", "; 523e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "..."; 5242761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 525e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ")"; 5267e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 527e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "{ "; 528d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 529d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 530d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 531e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 5322761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 5332761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 534e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " }"; 5357e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 5362761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(PTy->getElementType()) << "*"; 5377e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 538e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "[" << ATy->getNumElements() << " x "; 5392761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(ATy->getElementType()) << "]"; 5407e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 541e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "opaque"; 5422761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 543b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 544e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "<unknown derived type>"; 5452761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 5462761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 547e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman return *Out; 5482761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 5492761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5502761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 551007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 552007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner bool PrintName) { 553e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (PrintType) { *Out << " "; printType(Operand->getType()); } 554e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman WriteAsOperandInternal(*Out, Operand, PrintName, TypeNames, &Table); 555007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 556007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 557007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 558c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 559eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getEndianness()) { 560e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::LittleEndian: *Out << "target endian = little\n"; break; 561e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::BigEndian: *Out << "target endian = big\n"; break; 562eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyEndianness: break; 563eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 564eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getPointerSize()) { 565e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::Pointer32: *Out << "target pointersize = 32\n"; break; 566e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::Pointer64: *Out << "target pointersize = 64\n"; break; 567eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyPointerSize: break; 568eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 569eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner 570007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 5716e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 57270cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 5737e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 5747e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 575007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 576e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\nimplementation ; Functions:\n"; 5775efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 578b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of the functions... 5797e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 5807e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 581009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 582009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 583c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 584e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (GV->hasName()) *Out << getLLVMName(GV->getName()) << " = "; 585d70684f7585a85c4248c1c224059478108741c70Chris Lattner 5864ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!GV->hasInitializer()) 587e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "external "; 5884ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 5894ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 590e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::InternalLinkage: *Out << "internal "; break; 591e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 592e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::WeakLinkage: *Out << "weak "; break; 593e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::AppendingLinkage: *Out << "appending "; break; 5944ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 5954ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 596d70684f7585a85c4248c1c224059478108741c70Chris Lattner 597e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << (GV->isConstant() ? "constant " : "global "); 5987a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 599d70684f7585a85c4248c1c224059478108741c70Chris Lattner 600d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (GV->hasInitializer()) 601d70684f7585a85c4248c1c224059478108741c70Chris Lattner writeOperand(GV->getInitializer(), false, false); 602d70684f7585a85c4248c1c224059478108741c70Chris Lattner 6037e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 604e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 60570cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 60670cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 607009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 608ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printSymbolTable - Run through symbol table looking for named constants 609ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// if a named constant is found, emit it's declaration... 610ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 611c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 612007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) { 613007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator I = ST.type_begin(TI->first); 614007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner SymbolTable::type_const_iterator End = ST.type_end(TI->first); 615007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 616007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner for (; I != End; ++I) { 617007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner const Value *V = I->second; 618949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CPV = dyn_cast<Constant>(V)) { 619c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printConstant(CPV); 620949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Type *Ty = dyn_cast<Type>(V)) { 62154baafd28649a93c7c16ada4529b9212dc03aa05Chris Lattner assert(Ty->getType() == Type::TypeTy && TI->first == Type::TypeTy); 622e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t" << getLLVMName(I->first) << " = type "; 6232761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6242761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // Make sure we print out at least one level of the type structure, so 6252761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // that we do not get %FILE = type %FILE 6262761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6272761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printTypeAtLeastOneLevel(Ty) << "\n"; 628007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 629007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 630739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 631009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 632009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 633009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 634ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printConstant - Print out a constant pool entry... 635ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 636e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 637007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 638007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 639009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6401333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 641e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t" << getLLVMName(CPV->getName()) << " ="; 642009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 643009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 6447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 645009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6467e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 647e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 648009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 649009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 650ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 651ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 6527e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 653009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 654e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 6554ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 656e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, *Out); 65795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 6584ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 659e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "declare "; 6604ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 6614ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 662e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::InternalLinkage: *Out << "internal "; break; 663e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 664e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::WeakLinkage: *Out << "weak "; break; 665e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::AppendingLinkage: *Out << "appending "; break; 6664ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 6674ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 6684ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 669b8565e3918d2e5d43a8e53f545a8a1c587582fd3Chris Lattner printType(F->getReturnType()) << " "; 6704d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 671e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << getLLVMName(F->getName()); 6724d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 673e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\"\""; 674e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 6757e70829632f82de15db187845666aaca6e04b792Chris Lattner Table.incorporateFunction(F); 676007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 677c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 6787e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 679007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 68069da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 68169da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 682007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 683007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 6847e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 685e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (FT->getNumParams()) *Out << ", "; 686e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "..."; // Output varargs portion of signature! 687007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 688e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ")"; 689007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 6907e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 691e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 69203e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 693e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " {"; 694007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 695b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 6967e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 6977e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 698007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 699e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "}\n"; 700007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 701007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 702b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner Table.purgeFunction(); 703009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 704009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 705ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 706ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 707ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 70873e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 709009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 710e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (Arg != &Arg->getParent()->afront()) *Out << ", "; 711009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 712009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 713c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 714009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 715009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 716009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 717e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " " << getLLVMName(Arg->getName()); 71860596382aa6d2f54949684a07f5ab0ab881896d7Alkis Evlogimenos else if (Table.getSlot(Arg) < 0) 719e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "<badref>"; 720009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 721009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 722ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 723ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 724c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 725009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 726e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n" << BB->getName() << ":"; 727afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 72860596382aa6d2f54949684a07f5ab0ab881896d7Alkis Evlogimenos int Slot = Table.getSlot(BB); 729e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n; <label>:"; 730009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Slot >= 0) 731e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << Slot; // Extra newline separates out label's 732009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner else 733e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "<badref>"; 734061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 7354e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 7364e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 737e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t; Error: Block without parent!"; 7384e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner else { 7394e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB != &BB->getParent()->front()) { // Not the entry block? 7404e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner // Output predecessors for the block... 741e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t;"; 7424e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 7434e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 7444e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (PI == PE) { 745e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " No predecessors!"; 7464e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } else { 747e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " preds ="; 74840efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner writeOperand(*PI, false, true); 7494e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner for (++PI; PI != PE; ++PI) { 750e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 7514e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner writeOperand(*PI, false, true); 7524e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } 75340efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 754061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 755009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 756afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner 757e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 758009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 759e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, *Out); 76095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 761007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 7627e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 7637e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 7649f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 765e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, *Out); 766009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 767009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 768e02fa8551d20081534afa46e0976811687e5183aChris Lattner 769ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 770ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 771ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7727e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 7737e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 774e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t; <"; 7757e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(V.getType()) << ">"; 776e02fa8551d20081534afa46e0976811687e5183aChris Lattner 7777e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 77860596382aa6d2f54949684a07f5ab0ab881896d7Alkis Evlogimenos int Slot = Table.getSlot(&V); // Print out the def slot taken... 779e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (Slot >= 0) *Out << ":" << Slot; 780e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman else *Out << ":<badref>"; 781e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 782e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " [#uses=" << V.use_size() << "]"; // Output # uses 783e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 784e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 785e02fa8551d20081534afa46e0976811687e5183aChris Lattner 786ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInstruction - This member is called for each Instruction in a method. 787ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7887e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 789e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, *Out); 79095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 791e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t"; 792009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 793009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 7947e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 795e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << getLLVMName(I.getName()) << " = "; 796009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 797e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner // If this is a volatile load or store, print out the volatile marker 798e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 799e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) 800e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "volatile "; 801e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 802009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 803e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << I.getOpcodeName(); 804009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 805009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 8067e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 807009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 808009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 8097e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 8107e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 811e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 812009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 813e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 8147e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 815009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 81694dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 817009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 818e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(Operand , true); *Out << ","; 819e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(1), true); *Out << " ["; 820009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8217e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 822e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n\t\t"; 823e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op ), true); *Out << ","; 8247e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 825009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 826e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n\t]"; 827b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 828e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 8297e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 830e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 831009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8327e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 833e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (op) *Out << ", "; 834e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "["; 835e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op ), false); *Out << ","; 836e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op+1), false); *Out << " ]"; 837c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 838e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 839e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " void"; 840e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 8417a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 8427a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 8437a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 844268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 8457a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 846b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 8477a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 848268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 8497a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 85094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner (!isa<PointerType>(RetTy) || 851c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 852e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; printType(RetTy); 853268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 854268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 855268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 856268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 857e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 8587e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 8597e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 860e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 8617e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 862009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 863009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 864e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " )"; 8657e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 8667a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 8677a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 8687a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 8697a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 8707a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 8717a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 8727a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 8737a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 8747a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 8757a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner (!isa<PointerType>(RetTy) || 8767a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 877e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; printType(RetTy); 8787a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 8797a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 8807a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 8817a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 8827a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 883e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 8847e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 8857e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 886e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 8877e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 888e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 889e02fa8551d20081534afa46e0976811687e5183aChris Lattner 890e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " )\n\t\t\tto"; 891e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 892e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " unwind"; 893aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 894e02fa8551d20081534afa46e0976811687e5183aChris Lattner 8957e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 896e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 89794dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 89894dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 899e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 90094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 901009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 902e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 90341495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 904e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " to "; 9057e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 9064d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 90741495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 908e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 9098f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 9104d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) { 91141495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 912e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 9134d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner printType(VAN->getArgType()); 914009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 915009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 916009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 917009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 918009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 919009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 920009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 921009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 922cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // Shift Left & Right print both types even for Ubyte LHS, and select prints 923cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // types even if all operands are bools. 924cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner if (isa<ShiftInst>(I) || isa<SelectInst>(I)) { 925ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 926ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 927ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 928ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 929ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 930ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 931ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 932ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 933009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 934009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 935ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner 936c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 937e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 938ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 939c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 940009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9417e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 942e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (i) *Out << ","; 9437e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 944009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 945009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 946009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 947e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 948e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 949009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 950009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 951009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 952009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 953009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 954009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 955009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 95695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 9572ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner SlotCalculator SlotTable(this, false); 95895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 95975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 960009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 961009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 96275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 9632ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner SlotCalculator SlotTable(getParent(), false); 96495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 96575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 966b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 967b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 96895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 9692ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner SlotCalculator SlotTable(getParent(), false); 97095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 971009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 97275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 973009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 974009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 97595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 9762ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner SlotCalculator SlotTable(getParent(), false); 97775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, 97895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 97975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 98075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 981009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 98295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 98375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 9842ff95b6b4e9bcc0167a32f0ed09120298b5a3713Chris Lattner SlotCalculator SlotTable(F, false); 98595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 986009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 98775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 98875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 989009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 99075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 99175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 9923bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 9933bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner // Handle CPR's special, because they have context information... 9943bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { 9953bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner CPR->getValue()->print(o); // Print as a global value, with context info. 9963bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner return; 9973bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner } 9983bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 99966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner o << " " << getType()->getDescription() << " "; 100066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 10017b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeTable; 100266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner WriteConstantInt(o, this, false, TypeTable, 0); 1003009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1004009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 100575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Type::print(std::ostream &o) const { 100675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 100775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 100875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 100975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1010009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1011009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 101273e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 101375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getType() << " " << getName(); 101475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1015009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 101675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Value::dump() const { print(std::cerr); } 1017009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 101875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 101975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 102075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 1021da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1022da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 1023da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 1024da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 10258ce750145db529a3f5f09aeffba52194e879c7a3Chris Lattner SC = new SlotCalculator(M, false); 10265cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman AW = new AssemblyWriter(*Out, *SC, M, 0); 1027da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 1028da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 1029da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1030da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1031da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1032da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 1033da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 1034da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 1035da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1036da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1037da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter &CachedWriter::operator<<(const Value *V) { 1038da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 1039da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner switch (V->getValueType()) { 1040da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ConstantVal: 104166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner case Value::ArgumentVal: AW->writeOperand(V, true, true); break; 1042949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner case Value::TypeVal: AW->write(cast<Type>(V)); break; 1043da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 1044da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 104579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionVal: AW->write(cast<Function>(V)); break; 1046da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 10475cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman default: *Out << "<unknown value type: " << V->getValueType() << ">"; break; 1048da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1049da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 1050da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 10515cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 10525cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha BrukmanCachedWriter& CachedWriter::operator<<(const Type *X) { 10535cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (SymbolicTypes) { 10545cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module *M = AW->getModule(); 10555cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (M) WriteTypeSymbolic(*Out, X, M); 10565cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman return *this; 10575cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman } else 10585cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman return *this << (const Value*)X; 10595cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman} 1060e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman 1061e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukmanvoid CachedWriter::setStream(std::ostream &os) { 1062e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman Out = &os; 1063e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AW) AW->setStream(os); 1064e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman} 1065