AsmWriter.cpp revision 22379bc7bb28fbfb1182877e6dc316aaab98a4ba
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 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. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 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 1775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 18f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 1995e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner#include "llvm/Assembly/AsmAnnotationWriter.h" 20d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner#include "llvm/CallingConv.h" 21f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Constants.h" 223eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 23863517aea0b06770c809396be985c1c4cc50d3c4Chris Lattner#include "llvm/InlineAsm.h" 24b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 2544336292fcd9f3f99cbfc2c3366bea0cf95bb675Misha Brukman#include "llvm/Instructions.h" 26f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Module.h" 27007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 2878d033e086e19e016273de014f9214aa6f3f844bReid Spencer#include "llvm/TypeSymbolTable.h" 29551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/StringExtras.h" 30551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/STLExtras.h" 318f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling#include "llvm/Support/CFG.h" 32cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey#include "llvm/Support/MathExtras.h" 338f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling#include "llvm/Support/Streams.h" 34007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 3531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 36d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 370a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattnernamespace llvm { 380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 39edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer// Make virtual table appear in this compilation unit. 40edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid SpencerAssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 41edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer 420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// This class provides computation of slot numbers for LLVM Assembly writing. 430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @brief LLVM Assembly Writing Slot Computation. 440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerclass SlotMachine { 450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Types 470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A mapping of Values to slot numbers 510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer typedef std::map<const Value*, unsigned> ValueMap; 520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A plane with next slot number and ValueMap 54fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman struct ValuePlane { 550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned next_slot; ///< The next slot number to use 560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap map; ///< The map of Value* -> unsigned 570e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer }; 590e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The map of planes by Type 610e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer typedef std::map<const Type*, ValuePlane> TypedPlanes; 620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Constructors 650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a module 68c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner SlotMachine(const Module *M); 690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a function, starting out in incorp state. 71c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner SlotMachine(const Function *F); 720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Accessors 750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Return the slot number of the specified value in it's type 7822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner /// plane. If something is not in the SlotMachine, return -1. 7922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int getLocalSlot(const Value *V); 8022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int getGlobalSlot(const GlobalValue *V); 81fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer 820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Mutators 840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 86fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// If you'd like to deal with a function instead of just a module, use 870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// this method to get its data into the SlotMachine. 88fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman void incorporateFunction(const Function *F) { 89fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman TheFunction = F; 9028531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 9128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer } 920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 93fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// After calling incorporateFunction, use this method to remove the 94fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// most recently incorporated function from the SlotMachine. This 950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// will reset the state of the machine back to just the module contents. 960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void purgeFunction(); 970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Implementation Details 1000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerprivate: 102b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// This function does the actual initialization. 103b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer inline void initialize(); 104b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1059446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 1069446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner void CreateModuleSlot(const GlobalValue *V); 1079446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 1089446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner /// CreateFunctionSlot - Insert the specified Value* into the slot table. 1099446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner void CreateFunctionSlot(const Value *V); 1100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Add all of the module level global variables (and their initializers) 1120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// and function declarations, but not the contents of those functions. 1130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void processModule(); 1140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 115b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// Add all of the functions arguments, basic blocks, and instructions 116b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void processFunction(); 117b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 1190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void operator=(const SlotMachine &); // DO NOT IMPLEMENT 1200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Data 1230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 1250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The module for which we are holding slot numbers 127b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Module* TheModule; 1280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 129b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// @brief The function for which we are holding slot numbers 130b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Function* TheFunction; 13128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer bool FunctionProcessed; 1320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the module level data 1340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes mMap; 1350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the function level data 1370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes fMap; 1380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer}; 1420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1430a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner} // end namespace llvm 1440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1457f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintModulePass> 1463dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerX("printm", "Print module to stderr"); 1477f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintFunctionPass> 1483dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerY("print","Print function to stderr"); 149f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 150fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 151919e70c3ffe14e1de15f85599a796d1aaa714e67Chris Lattner std::map<const Type *, std::string> &TypeTable, 1520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine); 1530e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 154207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 155949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 157949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 158207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 159949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 16079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 162949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 163207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 165207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 166207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerstatic SlotMachine *createSlotMachine(const Value *V) { 168949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 1690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(FA->getParent()); 170949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 1710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(I->getParent()->getParent()); 172949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 1730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(BB->getParent()); 174949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 1750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(GV->getParent()); 176949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 1770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(Func); 178c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 179c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 180c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 181009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 18224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 18324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 18424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 1859913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenosstatic std::string getLLVMName(const std::string &Name, 1869913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos bool prefixName = true) { 18724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 18824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 18924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 19024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 19124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 19224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 19324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 19424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 19524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 19624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 19724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 19824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 19924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 20024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 201fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 20224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 2039913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos if (prefixName) 2049913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos return "%"+Name; 2059913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos else 2069913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos return Name; 20724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 20824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 209207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 210ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 211ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 212ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 213207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 2147b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 2156e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 21678d033e086e19e016273de014f9214aa6f3f844bReid Spencer const TypeSymbolTable &ST = M->getTypeSymbolTable(); 21778d033e086e19e016273de014f9214aa6f3f844bReid Spencer TypeSymbolTable::const_iterator TI = ST.begin(); 21878d033e086e19e016273de014f9214aa6f3f844bReid Spencer for (; TI != ST.end(); ++TI) { 2199231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // As a heuristic, don't insert pointer to primitive types, because 2209231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // they are used too often to have a single useful name. 2219231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 2229231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Type *Ty = cast<Type>(TI->second); 2239231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer if (!isa<PointerType>(Ty) || 224b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 225b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 2269231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 227207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 228207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 229207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 230207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 231207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 232fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void calcTypeName(const Type *Ty, 2334ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::vector<const Type *> &TypeStack, 2344ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::map<const Type *, std::string> &TypeNames, 2354ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string & Result){ 2364ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) { 2374ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += Ty->getDescription(); // Base case 2384ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2394ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 240207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 241207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2427b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 2434ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (I != TypeNames.end()) { 2444ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += I->second; 2454ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2464ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 247207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2484ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (isa<OpaqueType>(Ty)) { 2494ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 2504ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2514ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 25288c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 253207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 254207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 255207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 256207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 257fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // This is another base case for the recursion. In this case, we know 258207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 259207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 2604ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Slot < CurSize) { 2614ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 2624ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2634ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 264207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 265207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 266fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 267f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 2686bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 269949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 2704ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 2714ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += " ("; 272bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer unsigned Idx = 1; 273d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 274d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 275d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 276207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 2774ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 278bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (FTy->getParamAttrs(Idx)) { 279bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Result += + " "; 280bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); 281bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer } 282bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Idx++; 283207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 2842761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 285d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 286207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 287207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 288207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 2892c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer if (FTy->getParamAttrs(0)) { 2902c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Result += " "; 2912c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Result += FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); 2922c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer } 293207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 294207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 295207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 296949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 29738ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 29838ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Result += '<'; 2994ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "{ "; 300d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 301d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 302d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 303207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3044ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 305207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 306207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 30738ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 30838ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Result += '>'; 309207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 310207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 311207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 312fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman calcTypeName(cast<PointerType>(Ty)->getElementType(), 3134ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell TypeStack, TypeNames, Result); 3144ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "*"; 315207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 316207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 317949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 3184ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "[" + utostr(ATy->getNumElements()) + " x "; 3194ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 3204ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "]"; 321207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 322207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 323715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke case Type::PackedTyID: { 324715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke const PackedType *PTy = cast<PackedType>(Ty); 325715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += "<" + utostr(PTy->getNumElements()) + " x "; 326715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); 327715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += ">"; 328715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke break; 329715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 3309e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 3314ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 3329e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 333207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 3344ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "<unrecognized-type>"; 33582c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner break; 336207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 337207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 338207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 339207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 340207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 341207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3429d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 3439d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 3449d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 3457b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 3467b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 347207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 348207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 349207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 350daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 351daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 352207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 353207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 3547b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 355207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 356207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 357207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 358207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 359207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 360207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 3617b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 3624ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string TypeName; 3634ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(Ty, TypeStack, TypeNames, TypeName); 364697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 3654ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return (Out << TypeName); 366207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 367207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 368e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 3699d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 3709d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 3719d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 3729d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 37331f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 37431f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 375fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << ' '; 376207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 37782c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner // If they want us to print out a type, but there is no context, we can't 37882c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner // print it symbolically. 37982c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner if (!M) 3807b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 38182c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner 38282c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner std::map<const Type *, std::string> TypeNames; 38382c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner fillTypeNameTable(M, TypeNames); 38482c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner return printTypeInt(Out, Ty, TypeNames); 385207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 386207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 38718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// PrintEscapedString - Print each character of the specified string, escaping 38818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// it if it is not printable or if it is an escape char. 38918365506ebe3e28593cb36951f17f08e75712a29Chris Lattnerstatic void PrintEscapedString(const std::string &Str, std::ostream &Out) { 39018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner for (unsigned i = 0, e = Str.size(); i != e; ++i) { 39118365506ebe3e28593cb36951f17f08e75712a29Chris Lattner unsigned char C = Str[i]; 39218365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (isprint(C) && C != '"' && C != '\\') { 39318365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << C; 39418365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } else { 39518365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << '\\' 39618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 39718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 39818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 39918365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 40018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner} 40118365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 40282c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattnerstatic const char *getPredicateText(unsigned predicate) { 40381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer const char * pred = "unknown"; 40481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer switch (predicate) { 40581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_FALSE: pred = "false"; break; 40681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 40781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGT: pred = "ogt"; break; 40881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGE: pred = "oge"; break; 40981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLT: pred = "olt"; break; 41081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLE: pred = "ole"; break; 41181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ONE: pred = "one"; break; 41281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ORD: pred = "ord"; break; 41381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNO: pred = "uno"; break; 41481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 41581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGT: pred = "ugt"; break; 41681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGE: pred = "uge"; break; 41781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULT: pred = "ult"; break; 41881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULE: pred = "ule"; break; 41981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNE: pred = "une"; break; 42081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_TRUE: pred = "true"; break; 42181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_EQ: pred = "eq"; break; 42281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_NE: pred = "ne"; break; 42381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGT: pred = "sgt"; break; 42481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGE: pred = "sge"; break; 42581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLT: pred = "slt"; break; 42681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLE: pred = "sle"; break; 42781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGT: pred = "ugt"; break; 42881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGE: pred = "uge"; break; 42981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULT: pred = "ult"; break; 43081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULE: pred = "ule"; break; 43181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer } 43281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer return pred; 43381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer} 43481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer 435fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// @brief Internal constant writer. 436fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 4377b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 4380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 43938a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey const int IndentSize = 4; 44038a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey static std::string Indent = "\n"; 44166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 4429fb471df2ee4a35fd94ebf8156f76a83eacfffbbChris Lattner Out << (CB->getValue() ? "true" : "false"); 443b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 4449d908e8ca0314a8952b562de9d7e44bcf71426b1Reid Spencer Out << CI->getSExtValue(); 44566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 44666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 44766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 44866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 44966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 45066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 45166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 45266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 45366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 45466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 45566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 45666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 45766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 45866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 459b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 46066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 46166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 46271d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner Out << StrVal; 46371d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner return; 46466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 465fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 46666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 46766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 46871d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && 46966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 470cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())); 47166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 472de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 473de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 47466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 47566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 47666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 477fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // 47866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 47918365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (CA->isString()) { 48066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 48118365506ebe3e28593cb36951f17f08e75712a29Chris Lattner PrintEscapedString(CA->getAsString(), Out); 48266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 48366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 48466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 48540c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '['; 4867a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 48740c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 48866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 4902fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner TypeTable, Machine); 4917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 4927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 49366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4942fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine); 4957a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4967a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4977a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 4987a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4997a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 50043f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth if (CS->getType()->isPacked()) 50143f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth Out << '<'; 50240c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '{'; 503a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey unsigned N = CS->getNumOperands(); 504a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey if (N) { 50538a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) { 50638a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Indent += std::string(IndentSize, ' '); 50738a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << Indent; 50838a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } else { 50938a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << ' '; 51038a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } 5117a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 5127a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5132fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine); 5147a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 515a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey for (unsigned i = 1; i < N; i++) { 5167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 51738a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Out << Indent; 5187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 5197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5202fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine); 5217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 52238a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Indent.resize(Indent.size() - IndentSize); 5237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 524a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey 5257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 52643f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth if (CS->getType()->isPacked()) 52743f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth Out << '>'; 528715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) { 529715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke const Type *ETy = CP->getType()->getElementType(); 530fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(CP->getNumOperands() > 0 && 531715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke "Number of operands for a PackedConst must be > 0"); 532715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << '<'; 533715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ' '; 534715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 5352fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine); 536715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { 537715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ", "; 538715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 5392fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine); 540715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 541715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << " >"; 5427a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 5437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 5447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 545b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner } else if (isa<UndefValue>(CV)) { 546b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner Out << "undef"; 547b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner 548c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 54981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << CE->getOpcodeName(); 55081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer if (CE->isCompare()) 55181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(CE->getPredicate()); 55281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " ("; 553fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 554b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 555b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 5562fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, *OI, TypeTable, Machine); 557b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 558c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 559b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 560fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 5613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (CE->isCast()) { 56295586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 56395586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 56495586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 5653da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 56640c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ')'; 56795586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 5687a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 569b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 5707a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5717a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 5727a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5737a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 574ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 575ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 576ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 577ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 578fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 5797b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 5800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 58140c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 5822fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (V->hasName()) 58324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 5847970396014eacbe719eb171448ddc546c1ad2289Reid Spencer else { 5857970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CV = dyn_cast<Constant>(V); 58680cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (CV && !isa<GlobalValue>(CV)) { 5872fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteConstantInt(Out, CV, TypeTable, Machine); 58880cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 58980cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "asm "; 59080cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (IA->hasSideEffects()) 59180cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "sideeffect "; 59280cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 59380cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getAsmString(), Out); 59480cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "\", \""; 59580cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getConstraintString(), Out); 59680cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 59780cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else { 5987a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 5990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine) { 60022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 60122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getGlobalSlot(GV); 60222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner else 60322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getLocalSlot(V); 6047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 6050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine = createSlotMachine(V); 60622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (Machine) { 60722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 60822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getGlobalSlot(GV); 60922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner else 61022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getLocalSlot(V); 61122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner } else { 61269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = -1; 61322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner } 614b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer delete Machine; 6157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 61669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 61769566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << '%' << Slot; 61869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 61969566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << "<badref>"; 6207a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6227a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 6237a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6249d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 6259d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 6269d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 6279d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 62831f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 629a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner bool PrintType, const Module *Context) { 6307b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 631607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 6327a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6336e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 634607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 635207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 6367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 6377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 638fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 6392fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, V, TypeNames, 0); 640622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 641622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 642622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 6430e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 64431f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 645d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 646007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 6470313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman std::ostream &Out; 6480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine &Machine; 649c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 6507b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 65195e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 652009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 6530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 65495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 6550313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 656c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 657c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 658c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 659c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 660207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 661009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 662009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 663c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 664c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 66579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 666c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 6677e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 668e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 669da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 670009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 6712fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner void writeOperand(const Value *Op, bool PrintType); 67266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 6735cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 6745cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 675f771bea7402f05f59b2857586de9934ff1c7bbf5Misha Brukmanprivate: 676c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 67778d033e086e19e016273de014f9214aa6f3f844bReid Spencer void printTypeSymbolTable(const TypeSymbolTable &ST); 67878d033e086e19e016273de014f9214aa6f3f844bReid Spencer void printValueSymbolTable(const SymbolTable &ST); 679e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 680c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 68179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 682bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer void printArgument(const Argument *FA, FunctionType::ParameterAttributes A); 683c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 6847e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 6852761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6862761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 6872761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 6882761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6897b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 6900313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return printTypeInt(Out, Ty, TypeNames); 6912761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 6922761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6932761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 6942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 6952761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6967b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 697c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 698e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 699e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 7007e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 701009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 70273b7495a96e21e1515df86414e0636dbf1395fc5Reid Spencer} // end of llvm namespace 703009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 704ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 705ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 706ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7077b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 7087e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 709bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer printType(FTy->getReturnType()); 710bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << " ("; 711bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer unsigned Idx = 1; 712d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 713d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 714d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 7150313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 7167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 717bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (FTy->getParamAttrs(Idx)) { 718bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << " " << FunctionType::getParamAttrsText(FTy->getParamAttrs(Idx)); 719bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer } 720bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Idx++; 7212761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7222761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 7230313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FTy->getNumParams()) Out << ", "; 7240313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; 7252761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7260313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 7272c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer if (FTy->getParamAttrs(0)) 7282c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << ' ' << FunctionType::getParamAttrsText(FTy->getParamAttrs(0)); 7297e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 73038ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 73138ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Out << '<'; 7320313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "{ "; 733d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 734d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 735d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 7360313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 7372761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 7382761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7390313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " }"; 74038ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 74138ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Out << '>'; 7427e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 74340c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(PTy->getElementType()) << '*'; 7447e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 7450313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '[' << ATy->getNumElements() << " x "; 74640c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(ATy->getElementType()) << ']'; 7475527c0b6d1bda2c63212f91837792663469fd764Reid Spencer } else if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 7485527c0b6d1bda2c63212f91837792663469fd764Reid Spencer Out << '<' << PTy->getNumElements() << " x "; 7495527c0b6d1bda2c63212f91837792663469fd764Reid Spencer printType(PTy->getElementType()) << '>'; 7505527c0b6d1bda2c63212f91837792663469fd764Reid Spencer } 7513ed469ccd7b028a030b550d84b7336d146f5d8faReid Spencer else if (isa<OpaqueType>(Ty)) { 7520313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "opaque"; 7532761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 754b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 7550313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<unknown derived type>"; 7562761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 7572761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7580313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return Out; 7592761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 7602761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7612761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7622fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 7632fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (Operand == 0) { 764aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner Out << "<null operand!>"; 7652fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner } else { 7662fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (PrintType) { Out << ' '; printType(Operand->getType()); } 7672fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 768aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner } 769007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 770007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 771007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 772c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 77331ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner if (!M->getModuleIdentifier().empty() && 774fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // Don't print the ID if it will start a new line (which would 77531ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner // require a comment char before it). 77631ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner M->getModuleIdentifier().find('\n') == std::string::npos) 77731ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 77831ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner 779cf7ff2b4c8c18d67aced9d7ba84482819b38a84bOwen Anderson if (!M->getDataLayout().empty()) 780d2f9e609aa40de7049ebb6f838e7ba6579e3fb6aChris Lattner Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 781cf7ff2b4c8c18d67aced9d7ba84482819b38a84bOwen Anderson 782eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getEndianness()) { 7830313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::LittleEndian: Out << "target endian = little\n"; break; 7840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::BigEndian: Out << "target endian = big\n"; break; 785eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyEndianness: break; 786eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 787eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getPointerSize()) { 7880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer32: Out << "target pointersize = 32\n"; break; 7890313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer64: Out << "target pointersize = 64\n"; break; 790eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyPointerSize: break; 791eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 792cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (!M->getTargetTriple().empty()) 793c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 794fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 795cc041ba03aed685400197fb938b7a583713d25afChris Lattner if (!M->getModuleInlineAsm().empty()) { 79642a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // Split the string into lines, to make it easier to read the .ll file. 797cc041ba03aed685400197fb938b7a583713d25afChris Lattner std::string Asm = M->getModuleInlineAsm(); 79842a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t CurPos = 0; 79942a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t NewLine = Asm.find_first_of('\n', CurPos); 80042a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner while (NewLine != std::string::npos) { 80142a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // We found a newline, print the portion of the asm string from the 80242a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // last newline up to this newline. 80342a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "module asm \""; 80442a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 80542a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out); 80642a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "\"\n"; 80742a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner CurPos = NewLine+1; 80842a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner NewLine = Asm.find_first_of('\n', CurPos); 80942a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner } 81071cdba31774ce18ed32e89f1c6f7716ab923aa46Chris Lattner Out << "module asm \""; 81142a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); 81218365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << "\"\n"; 81318365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 81418365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 81544da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the dependent libraries and emit them. 816cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LI = M->lib_begin(); 817cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LE = M->lib_end(); 818cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (LI != LE) { 819cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << "deplibs = [ "; 820cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner while (LI != LE) { 82144da7d79760998f9a70340b49a3811229838224dChris Lattner Out << '"' << *LI << '"'; 822c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer ++LI; 823cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner if (LI != LE) 824cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << ", "; 825c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer } 826c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << " ]\n"; 82783f6a77c8fc27eba21bca05be37663f3a6e123a1Reid Spencer } 828e59eaf407a675845e278c2769e3dbed9f1daae8cReid Spencer 82944da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the symbol table, emitting all named constants. 83078d033e086e19e016273de014f9214aa6f3f844bReid Spencer printTypeSymbolTable(M->getTypeSymbolTable()); 83178d033e086e19e016273de014f9214aa6f3f844bReid Spencer printValueSymbolTable(M->getValueSymbolTable()); 832fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 833d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 834d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner I != E; ++I) 8357e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 836007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\nimplementation ; Functions:\n"; 838fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 83944da7d79760998f9a70340b49a3811229838224dChris Lattner // Output all of the functions. 8407e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 8417e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 842009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 843009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 844c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 8450313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; 846d70684f7585a85c4248c1c224059478108741c70Chris Lattner 847fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if (!GV->hasInitializer()) 848b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov switch (GV->getLinkage()) { 849b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 850b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 851b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov default: Out << "external "; break; 852b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } 8534ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 8544ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 855b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 856b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 857b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 858b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::AppendingLinkage: Out << "appending "; break; 859b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 860b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 861b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 862b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalLinkage: break; 8633c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman case GlobalValue::GhostLinkage: 864e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << "GhostLinkage not allowed in AsmWriter!\n"; 8653c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman abort(); 8664ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 867d70684f7585a85c4248c1c224059478108741c70Chris Lattner 8680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << (GV->isConstant() ? "constant " : "global "); 8697a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 870d70684f7585a85c4248c1c224059478108741c70Chris Lattner 8717970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (GV->hasInitializer()) { 8727970396014eacbe719eb171448ddc546c1ad2289Reid Spencer Constant* C = cast<Constant>(GV->getInitializer()); 8737970396014eacbe719eb171448ddc546c1ad2289Reid Spencer assert(C && "GlobalVar initializer isn't constant?"); 8742fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(GV->getInitializer(), false); 8757970396014eacbe719eb171448ddc546c1ad2289Reid Spencer } 87630caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner 87760962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->hasSection()) 87860962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << ", section \"" << GV->getSection() << '"'; 87960962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->getAlignment()) 88030caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << ", align " << GV->getAlignment(); 88160962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner 8827e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 8830313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 88470cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 88570cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 88678d033e086e19e016273de014f9214aa6f3f844bReid Spencervoid AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) { 8879231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the types. 88878d033e086e19e016273de014f9214aa6f3f844bReid Spencer for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end(); 88978d033e086e19e016273de014f9214aa6f3f844bReid Spencer TI != TE; ++TI) { 8900313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(TI->first) << " = type "; 8919231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 8929231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Make sure we print out at least one level of the type structure, so 8939231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // that we do not get %FILE = type %FILE 8949231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 8959231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer printTypeAtLeastOneLevel(TI->second) << "\n"; 8969231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer } 89778d033e086e19e016273de014f9214aa6f3f844bReid Spencer} 89878d033e086e19e016273de014f9214aa6f3f844bReid Spencer 89978d033e086e19e016273de014f9214aa6f3f844bReid Spencer// printSymbolTable - Run through symbol table looking for constants 90078d033e086e19e016273de014f9214aa6f3f844bReid Spencer// and types. Emit their declarations. 90178d033e086e19e016273de014f9214aa6f3f844bReid Spencervoid AssemblyWriter::printValueSymbolTable(const SymbolTable &ST) { 902fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 9039231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the constants, in type plane order. 9049231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 905c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner PI != ST.plane_end(); ++PI) { 9069231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 9079231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 9089231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 9099231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; VI != VE; ++VI) { 9107970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Value* V = VI->second; 9117970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CPV = dyn_cast<Constant>(V) ; 9127970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (CPV && !isa<GlobalValue>(V)) { 913b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer printConstant(CPV); 914007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 915007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 916739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 917009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 918009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 919009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 920ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printConstant - Print out a constant pool entry... 921ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 922e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 923007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 924007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 925009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9261333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 9270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(CPV->getName()) << " ="; 928009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9292fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner // Write the value out now. 9302fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(CPV, true); 931009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9327e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 9330313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 934009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 935009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 936ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 937ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 9387e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 939009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 9400313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 9414ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 942333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner // Ensure that no local symbols conflict with global symbols. 943333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner const_cast<Function*>(F)->renameLocalSymbols(); 944333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner 9450313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 94695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 9474ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 948b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov switch (F->getLinkage()) { 949b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "declare dllimport "; break; 950b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "declare extern_weak "; break; 951b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov default: Out << "declare "; 952b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } 953b951bc02839e9862e02e17c7ea83e6437fc13442Reid Spencer else { 954b951bc02839e9862e02e17c7ea83e6437fc13442Reid Spencer Out << "define "; 9554ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 956b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 957b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 958b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 959b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::AppendingLinkage: Out << "appending "; break; 960b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 961b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 962b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 9634ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 9643c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman case GlobalValue::GhostLinkage: 965e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << "GhostLinkage not allowed in AsmWriter!\n"; 9663c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman abort(); 9674ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 968b951bc02839e9862e02e17c7ea83e6437fc13442Reid Spencer } 9694ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 970d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention. 971d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (F->getCallingConv()) { 972d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 973f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::CSRet: Out << "csretcc "; break; 974f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Fast: Out << "fastcc "; break; 975f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Cold: Out << "coldcc "; break; 976f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 977f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 978d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << "cc" << F->getCallingConv() << " "; break; 979d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 980d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 981bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer const FunctionType *FT = F->getFunctionType(); 98240c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(F->getReturnType()) << ' '; 9834d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 9840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(F->getName()); 9854d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 9860313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\"\""; 9870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 9880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.incorporateFunction(F); 989007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 990c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 991007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 992bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer unsigned Idx = 1; 993d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 994bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer I != E; ++I) { 995bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer // Insert commas as we go... the first arg doesn't get a comma 996bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (I != F->arg_begin()) Out << ", "; 997bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer printArgument(I, FT->getParamAttrs(Idx)); 998bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Idx++; 999bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer } 1000007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1001007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 10027e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 10030313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FT->getNumParams()) Out << ", "; 10040313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; // Output varargs portion of signature! 1005007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 10060313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 10072c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer if (FT->getParamAttrs(0)) 10082c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << ' ' << FunctionType::getParamAttrsText(FT->getParamAttrs(0)); 100960962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (F->hasSection()) 101060962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << " section \"" << F->getSection() << '"'; 101130caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner if (F->getAlignment()) 101230caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << " align " << F->getAlignment(); 101360962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner 10147e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 10150313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 101603e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 10170313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " {"; 1018fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1019b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 10207e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 10217e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 1022007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 10230313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "}\n"; 1024007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 1025007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 10260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.purgeFunction(); 1027009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1028009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1029ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 1030ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 1031ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 1032bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencervoid AssemblyWriter::printArgument(const Argument *Arg, 1033bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer FunctionType::ParameterAttributes attrs) { 1034009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 1035c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 1036fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1037bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (attrs != FunctionType::NoAttributeSet) 1038bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << ' ' << FunctionType::getParamAttrsText(attrs); 1039bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer 1040009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 1041009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 10420313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' ' << getLLVMName(Arg->getName()); 1043009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1044009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1045ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 1046ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 1047c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1048009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 10499913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos Out << "\n" << getLLVMName(BB->getName(), false) << ':'; 1050afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 10510313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n; <label>:"; 105222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int Slot = Machine.getLocalSlot(BB); 105369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 10540313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << Slot; 105569566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 10560313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<badref>"; 1057061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 10584e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 10594e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 10600313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; Error: Block without parent!"; 10614e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner else { 10624e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB != &BB->getParent()->front()) { // Not the entry block? 10634e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner // Output predecessors for the block... 10640313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t;"; 10654e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 1066fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 10674e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (PI == PE) { 10680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " No predecessors!"; 10694e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } else { 10700313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " preds ="; 10712fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(*PI, false); 10724e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner for (++PI; PI != PE; ++PI) { 10730313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 10742fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(*PI, false); 10754e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } 107640efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 1077061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 1078009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1079fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 10800313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1081009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 10820313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 108395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 1084007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 10857e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 10867e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 10879f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 10880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1089009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1090009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1091e02fa8551d20081534afa46e0976811687e5183aChris Lattner 1092ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 1093ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 1094ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 10957e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 10967e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 10970313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; <"; 109840c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(V.getType()) << '>'; 1099e02fa8551d20081534afa46e0976811687e5183aChris Lattner 11007e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 110122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int SlotNum; 110222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V)) 110322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner SlotNum = Machine.getGlobalSlot(GV); 110422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner else 110522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner SlotNum = Machine.getLocalSlot(&V); 110669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (SlotNum == -1) 11070313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ":<badref>"; 1108fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer else 11090313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ':' << SlotNum; // Print out the def slot taken. 1110e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 11115c461404fed8d1def8eae02e6574bc5b16502575Chris Lattner Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses 1112e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1113e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 1114e02fa8551d20081534afa46e0976811687e5183aChris Lattner 11153a9ec2463ddeba0820f284e2952bd6919cd5e080Reid Spencer// This member is called for each Instruction in a function.. 11167e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 11170313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 111895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 11190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t"; 1120009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1121009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 11227e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 11230313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(I.getName()) << " = "; 1124009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1125ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a volatile load or store, print out the volatile marker. 1126e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1127ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) { 11280313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "volatile "; 1129ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) { 1130ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a call, check if it's a tail call. 1131ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner Out << "tail "; 1132ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } 1133e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 1134009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 11350313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << I.getOpcodeName(); 1136009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 113774f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer // Print out the compare instruction predicates 113874f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) { 113981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(FCI->getPredicate()); 114074f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) { 114181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(ICI->getPredicate()); 114274f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer } 114374f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer 1144009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 11457e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1146009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1147009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 11487e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 11497e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 11500313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 1151009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 11520313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 11537e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 1154009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 115594dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 1156009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 11570313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(Operand , true); Out << ','; 11580313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(1), true); Out << " ["; 1159009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11607e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 11610313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t\t"; 11620313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), true); Out << ','; 11637e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 1164009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 11650313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t]"; 1166b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 11670313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 11687e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 11690313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1170009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11717e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 11720313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (op) Out << ", "; 1173fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << '['; 11740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), false); Out << ','; 11750313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op+1), false); Out << " ]"; 1176c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 1177e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 11780313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " void"; 1179d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1180d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1181d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (CI->getCallingConv()) { 1182d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 11830deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::CSRet: Out << " csretcc"; break; 11840deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 11850deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1186f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1187f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1188d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << CI->getCallingConv(); break; 1189d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1190d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 11917a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 11927a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 11937a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 1194268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 11957a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 1196b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 11977a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 1198268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 11997a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1200fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 1201c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 12020313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 1203268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 1204268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 1205268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 1206268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 12070313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 1208bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { 1209bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (op > 1) 1210bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << ','; 12117e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 1212bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (FTy->getParamAttrs(op) != FunctionType::NoAttributeSet) 1213bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op)); 1214009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 12150313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )"; 12162c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet) 12172c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << ' ' << FTy->getParamAttrsText(FTy->getParamAttrs(0)); 12187e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 12197a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 12207a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 12217a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 12227a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 1223d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1224d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (II->getCallingConv()) { 1225d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 12260deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::CSRet: Out << " csretcc"; break; 12270deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 12280deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1229f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1230f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1231d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << II->getCallingConv(); break; 1232d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1233d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 12347a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 12357a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 12367a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 12377a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 12387a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1239fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 12407a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 12410313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 12427a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 12437a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 12447a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 12457a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 12467a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 12470313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 1248bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { 1249bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (op > 3) 1250bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << ','; 12517e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 12526359618e43a4434c14b4d997dfff2604f0c16c0aReid Spencer if (FTy->getParamAttrs(op-2) != FunctionType::NoAttributeSet) 12536359618e43a4434c14b4d997dfff2604f0c16c0aReid Spencer Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(op-2)); 1254e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1255e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12562c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << " )"; 12572c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer if (FTy->getParamAttrs(0) != FunctionType::NoAttributeSet) 12582c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << " " << FTy->getParamAttrsText(FTy->getParamAttrs(0)); 12592c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << "\n\t\t\tto"; 1260e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 12610313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " unwind"; 1262aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 1263e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12647e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 12650313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 126694dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 126794dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 12680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 126994dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 1270009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 127114b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman if (AI->getAlignment()) { 12729fad0b9974beb76bef763b8fed71d0c8644403d4Chris Lattner Out << ", align " << AI->getAlignment(); 127314b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman } 1274e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 127541495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 12760313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " to "; 12777e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 12784d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 127941495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 12800313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 12818f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 1282009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 1283009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1284fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // PrintAllTypes - Instructions who have operands of all the same type 1285009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 1286009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 1287009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 1288009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 1289009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1290cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // Shift Left & Right print both types even for Ubyte LHS, and select prints 1291cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // types even if all operands are bools. 129200f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I) || 129300f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner isa<ShuffleVectorInst>(I)) { 1294ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 1295ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 1296ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1297ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 1298ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 1299ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 1300ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 1301ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 1302009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1303009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1304fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1305c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 13060313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1307ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 1308c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 1309009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 13107e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 13110313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (i) Out << ','; 13127e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 1313009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1314009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1315009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1316e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 13170313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1318009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1319009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1320009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1321009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1322009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 1323009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1324009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 132595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(this); 132795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 132875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1329009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1330009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 133175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 13320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 133395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 133475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1335b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 1336b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 133795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 133995e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 1340009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 134175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1342009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1343009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1344cc041ba03aed685400197fb938b7a583713d25afChris Lattnervoid InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13452fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperand(o, this, true, 0); 1346cc041ba03aed685400197fb938b7a583713d25afChris Lattner} 1347cc041ba03aed685400197fb938b7a583713d25afChris Lattner 134895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 1350fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman AssemblyWriter W(o, SlotTable, 135195e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 135275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 135375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1354009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 135595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 135675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 13570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(F); 135895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1359009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 136075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 136175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1362009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 136375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 136475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 13653bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 136640c732cc52a5c71cead461646667ef5b13801923Misha Brukman o << ' ' << getType()->getDescription() << ' '; 1367a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng 1368a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng std::map<const Type *, std::string> TypeTable; 13692fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteConstantInt(o, this, TypeTable, 0); 1370009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1371009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1372fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanvoid Type::print(std::ostream &o) const { 137375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 137475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 137575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 137675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1377009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1378009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 137973e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 13802fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0); 138175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1382009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1383fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Value::dump - allow easy printing of Values from the debugger. 1384fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 1385832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendlingvoid Value::dump() const { print(*cerr.stream()); cerr << '\n'; } 1386fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer 1387fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Type::dump - allow easy printing of Values from the debugger. 1388fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 1389832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendlingvoid Type::dump() const { print(*cerr.stream()); cerr << '\n'; } 1390009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 139175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 139282c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner// SlotMachine Implementation 13930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 13940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#if 0 1396e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling#define SC_DEBUG(X) cerr << X 13970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#else 13980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) 13990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#endif 14000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Module level constructor. Causes the contents of the Module (sans functions) 14020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// to be added to the slot table. 1403fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanSlotMachine::SlotMachine(const Module *M) 1404b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule(M) ///< Saved for lazy initialization. 1405b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(0) 140628531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 14070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 14080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Function level constructor. Causes the contents of the Module and the one 14110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function provided to be added to the slot table. 1412c96ce89c97e1a051c00a169a46bac93838a82253Chris LattnerSlotMachine::SlotMachine(const Function *F) 1413c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization 1414b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(F) ///< Saved for lazy initialization 141528531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 14160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 1417b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer} 1418b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 141922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerinline void SlotMachine::initialize() { 1420c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner if (TheModule) { 1421fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processModule(); 1422b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheModule = 0; ///< Prevent re-processing next time we're called. 1423b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer } 1424de891a6c3583c47f0fd5d7b950f0fef3d06536e1Chris Lattner if (TheFunction && !FunctionProcessed) 1425fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processFunction(); 14260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Iterate through all the global variables, functions, and global 1429fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// variable initializers and create slots for them. 14300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::processModule() { 14310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processModule!\n"); 14320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1433a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all of the unnamed global variables to the value table. 1434d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner for (Module::const_global_iterator I = TheModule->global_begin(), 1435d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner E = TheModule->global_end(); I != E; ++I) 1436a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!I->hasName()) 14379446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateModuleSlot(I); 14380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1439a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all the unnamed functions to the table. 14400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 14410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 1442a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!I->hasName()) 14439446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateModuleSlot(I); 14440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processModule!\n"); 14460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1449b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// Process the arguments, basic blocks, and instructions of a function. 1450b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencervoid SlotMachine::processFunction() { 14510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processFunction!\n"); 14520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1453a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all the function arguments with no names. 1454fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 1455e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner AE = TheFunction->arg_end(); AI != AE; ++AI) 1456a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!AI->hasName()) 14579446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(AI); 14580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("Inserting Instructions:\n"); 14600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1461a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all of the basic blocks and instructions with no names. 1462fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for (Function::const_iterator BB = TheFunction->begin(), 1463b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer E = TheFunction->end(); BB != E; ++BB) { 1464a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!BB->hasName()) 14659446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(BB); 1466a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1467a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (I->getType() != Type::VoidTy && !I->hasName()) 14689446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(I); 14690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 147128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = true; 147228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer 14730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processFunction!\n"); 14740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1476de891a6c3583c47f0fd5d7b950f0fef3d06536e1Chris Lattner/// Clean up after incorporating a function. This is the only way to get out of 147722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// the function incorporation state that affects get*Slot/Create*Slot. Function 14783a4621c5f6e406da75c15e1351e2df5a7a4d9297Chris Lattner/// incorporation state is indicated by TheFunction != 0. 14790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::purgeFunction() { 14800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin purgeFunction!\n"); 14810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer fMap.clear(); // Simply discard the function level map 1482b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheFunction = 0; 148328531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 14840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end purgeFunction!\n"); 14850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 148722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// getGlobalSlot - Get the slot number of a global value. 148822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerint SlotMachine::getGlobalSlot(const GlobalValue *V) { 148922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Check for uninitialized state and do lazy initialization. 149022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner initialize(); 149122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 149222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Find the type plane in the module map 149322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner TypedPlanes::const_iterator MI = mMap.find(V->getType()); 149422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (MI == mMap.end()) return -1; 149522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 149622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Lookup the value in the module plane's map. 149722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner ValueMap::const_iterator MVI = MI->second.map.find(V); 149822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner return MVI != MI->second.map.end() ? MVI->second : -1; 149922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner} 1500b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 150122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 150222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// getLocalSlot - Get the slot number for a value that is local to a function. 150322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerint SlotMachine::getLocalSlot(const Value *V) { 150422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!"); 150522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 150622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Check for uninitialized state and do lazy initialization. 150722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner initialize(); 15080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type of the value 151022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner const Type *VTy = V->getType(); 15110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 151222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner TypedPlanes::const_iterator FI = fMap.find(VTy); 151322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (FI == fMap.end()) return -1; 151422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 151522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Lookup the Value in the function and module maps. 151622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner ValueMap::const_iterator FVI = FI->second.map.find(V); 15170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 151822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 151922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // If the value doesn't exist in the function map 152022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (FVI == FI->second.map.end()) { 152122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Look up the value in the module map. 152222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (MI == mMap.end()) return -1; 152322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner ValueMap::const_iterator MVI = MI->second.map.find(V); 152422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // If we didn't find it, it wasn't inserted 152522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (MVI == MI->second.map.end()) return -1; 152622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner assert(MVI != MI->second.map.end() && "Value not found"); 152722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // We found it only at the module level 152822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner return MVI->second; 15290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 153022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 153122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Return the slot number as the module's contribution to 153222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // the type plane plus the index in the function's contribution 153322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // to the type plane. 153422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (MI != mMap.end()) 153522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner return MI->second.next_slot + FVI->second; 153622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner else 153722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner return FVI->second; 15380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15400e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15419446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 15429446bbe7d4099eb5b917519d458a07ca08270471Chris Lattnervoid SlotMachine::CreateModuleSlot(const GlobalValue *V) { 1543cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner assert(V && "Can't insert a null Value into SlotMachine!"); 1544cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 1545cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner unsigned DestSlot = 0; 1546cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner const Type *VTy = V->getType(); 1547cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 154855e73a549359c949069550cbfc79b3e63c4c4119Chris Lattner ValuePlane &PlaneMap = mMap[VTy]; 154955e73a549359c949069550cbfc79b3e63c4c4119Chris Lattner DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++; 1550cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 1551cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1552cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner DestSlot << " ["); 1553cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner // G = Global, F = Function, o = other 1554cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 'F') << "]\n"); 15559446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner} 15569446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 15579446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 15583a4621c5f6e406da75c15e1351e2df5a7a4d9297Chris Lattner/// CreateSlot - Create a new slot for the specified value if it has no name. 15599446bbe7d4099eb5b917519d458a07ca08270471Chris Lattnervoid SlotMachine::CreateFunctionSlot(const Value *V) { 15609446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner const Type *VTy = V->getType(); 1561a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!"); 1562cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 15630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned DestSlot = 0; 1564cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 156555e73a549359c949069550cbfc79b3e63c4c4119Chris Lattner ValuePlane &PlaneMap = fMap[VTy]; 156655e73a549359c949069550cbfc79b3e63c4c4119Chris Lattner DestSlot = PlaneMap.map[V] = PlaneMap.next_slot++; 1567cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 15684932a5a3350a28a7cb41972036d6576401cc1b01Chris Lattner // G = Global, F = Function, o = other 1569cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1570cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner DestSlot << " [o]\n"); 1571cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner} 1572