AsmWriter.cpp revision aafce77b17d340aace52bcd49d1944109d82f14a
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// 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" 27ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer#include "llvm/ValueSymbolTable.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> 354ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer#include <cctype> 3631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 37d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 380a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattnernamespace llvm { 390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 40edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer// Make virtual table appear in this compilation unit. 41edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid SpencerAssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 42edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer 430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// This class provides computation of slot numbers for LLVM Assembly writing. 440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @brief LLVM Assembly Writing Slot Computation. 450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerclass SlotMachine { 460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Types 480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A mapping of Values to slot numbers 52590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer typedef std::map<const Value*,unsigned> ValueMap; 530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Constructors 560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a module 591327f69d98a2cb527b275ffc93080cf31ddf6dc5Dan Gohman explicit SlotMachine(const Module *M); 600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a function, starting out in incorp state. 621327f69d98a2cb527b275ffc93080cf31ddf6dc5Dan Gohman explicit SlotMachine(const Function *F); 630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Accessors 660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Return the slot number of the specified value in it's type 6922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner /// plane. If something is not in the SlotMachine, return -1. 7022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int getLocalSlot(const Value *V); 7122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int getGlobalSlot(const GlobalValue *V); 72fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer 730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Mutators 750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 77fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// If you'd like to deal with a function instead of just a module, use 780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// this method to get its data into the SlotMachine. 79fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman void incorporateFunction(const Function *F) { 80fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman TheFunction = F; 8128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 8228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer } 830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 84fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// After calling incorporateFunction, use this method to remove the 85fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// most recently incorporated function from the SlotMachine. This 860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// will reset the state of the machine back to just the module contents. 870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void purgeFunction(); 880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Implementation Details 910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerprivate: 93b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// This function does the actual initialization. 94b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer inline void initialize(); 95b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 969446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 979446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner void CreateModuleSlot(const GlobalValue *V); 989446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 999446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner /// CreateFunctionSlot - Insert the specified Value* into the slot table. 1009446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner void CreateFunctionSlot(const Value *V); 1010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Add all of the module level global variables (and their initializers) 1030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// and function declarations, but not the contents of those functions. 1040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void processModule(); 1050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 106b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// Add all of the functions arguments, basic blocks, and instructions 107b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void processFunction(); 108b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 1100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void operator=(const SlotMachine &); // DO NOT IMPLEMENT 1110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Data 1140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 1160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The module for which we are holding slot numbers 118b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Module* TheModule; 1190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 120b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// @brief The function for which we are holding slot numbers 121b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Function* TheFunction; 12228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer bool FunctionProcessed; 1230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the module level data 125590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer ValueMap mMap; 126590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer unsigned mNext; 1270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the function level data 129590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer ValueMap fMap; 130590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer unsigned fNext; 1310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer}; 1350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1360a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner} // end namespace llvm 1370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1381997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar PrintModulePass::ID = 0; 1397f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintModulePass> 1403dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerX("printm", "Print module to stderr"); 1411997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar PrintFunctionPass::ID = 0; 1427f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintFunctionPass> 1433dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerY("print","Print function to stderr"); 144f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 145fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 146919e70c3ffe14e1de15f85599a796d1aaa714e67Chris Lattner std::map<const Type *, std::string> &TypeTable, 1470e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine); 1480e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 149207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 150949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 151207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 152949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 153207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 154949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 15579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 157949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 158207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 160207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerstatic SlotMachine *createSlotMachine(const Value *V) { 163949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 1640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(FA->getParent()); 165949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 1660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(I->getParent()->getParent()); 167949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 1680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(BB->getParent()); 169949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 1700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(GV->getParent()); 1718b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)){ 1728b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov return new SlotMachine(GA->getParent()); 173949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 1740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(Func); 175c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 176c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 177c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 178009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1793702d265b8278c4b67efb4989e6724205908addfReid Spencer/// NameNeedsQuotes - Return true if the specified llvm name should be wrapped 1803702d265b8278c4b67efb4989e6724205908addfReid Spencer/// with ""'s. 1814ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencerstatic std::string QuoteNameIfNeeded(const std::string &Name) { 1824ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer std::string result; 1834ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer bool needsQuotes = Name[0] >= '0' && Name[0] <= '9'; 1844ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer // Scan the name to see if it needs quotes and to replace funky chars with 1854ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer // their octal equivalent. 18624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 18724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 18824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 1894ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer if (isalnum(C) || C == '-' || C == '.' || C == '_') 1904ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += C; 1914ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer else if (C == '\\') { 1924ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer needsQuotes = true; 1934ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += "\\\\"; 1944ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer } else if (isprint(C)) { 1954ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer needsQuotes = true; 1964ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += C; 1974ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer } else { 1984ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer needsQuotes = true; 1994ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += "\\"; 2004ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer char hex1 = (C >> 4) & 0x0F; 2014ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer if (hex1 < 10) 2024ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += hex1 + '0'; 2034ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer else 2044ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += hex1 - 10 + 'A'; 2054ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer char hex2 = C & 0x0F; 2064ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer if (hex2 < 10) 2074ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += hex2 + '0'; 2084ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer else 2094ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += hex2 - 10 + 'A'; 2104ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer } 2113702d265b8278c4b67efb4989e6724205908addfReid Spencer } 2124ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer if (needsQuotes) { 2134ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result.insert(0,"\""); 2144ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer result += '"'; 2154ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer } 2164ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer return result; 2173702d265b8278c4b67efb4989e6724205908addfReid Spencer} 2183702d265b8278c4b67efb4989e6724205908addfReid Spencer 2193702d265b8278c4b67efb4989e6724205908addfReid Spencerenum PrefixType { 2203702d265b8278c4b67efb4989e6724205908addfReid Spencer GlobalPrefix, 2213702d265b8278c4b67efb4989e6724205908addfReid Spencer LabelPrefix, 2223702d265b8278c4b67efb4989e6724205908addfReid Spencer LocalPrefix 2233702d265b8278c4b67efb4989e6724205908addfReid Spencer}; 2243702d265b8278c4b67efb4989e6724205908addfReid Spencer 2253702d265b8278c4b67efb4989e6724205908addfReid Spencer/// getLLVMName - Turn the specified string into an 'LLVM name', which is either 2263702d265b8278c4b67efb4989e6724205908addfReid Spencer/// prefixed with % (if the string only contains simple characters) or is 2273702d265b8278c4b67efb4989e6724205908addfReid Spencer/// surrounded with ""'s (if it has special chars in it). 2283702d265b8278c4b67efb4989e6724205908addfReid Spencerstatic std::string getLLVMName(const std::string &Name, PrefixType Prefix) { 2293702d265b8278c4b67efb4989e6724205908addfReid Spencer assert(!Name.empty() && "Cannot get empty name!"); 2303702d265b8278c4b67efb4989e6724205908addfReid Spencer switch (Prefix) { 2313702d265b8278c4b67efb4989e6724205908addfReid Spencer default: assert(0 && "Bad prefix!"); 2324ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer case GlobalPrefix: return '@' + QuoteNameIfNeeded(Name); 2334ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer case LabelPrefix: return QuoteNameIfNeeded(Name); 2344ad513ca153430c3a7f36be1ef43af04534e1f5dReid Spencer case LocalPrefix: return '%' + QuoteNameIfNeeded(Name); 2353702d265b8278c4b67efb4989e6724205908addfReid Spencer } 23624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 23724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 238207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 239ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 240ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 241ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 242207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 2437b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 2446e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 24578d033e086e19e016273de014f9214aa6f3f844bReid Spencer const TypeSymbolTable &ST = M->getTypeSymbolTable(); 24678d033e086e19e016273de014f9214aa6f3f844bReid Spencer TypeSymbolTable::const_iterator TI = ST.begin(); 24778d033e086e19e016273de014f9214aa6f3f844bReid Spencer for (; TI != ST.end(); ++TI) { 2489231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // As a heuristic, don't insert pointer to primitive types, because 2499231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // they are used too often to have a single useful name. 2509231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 2519231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Type *Ty = cast<Type>(TI->second); 2529231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer if (!isa<PointerType>(Ty) || 253b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 25442a75517250017a52afb03a0ade03cbd49559fe5Chris Lattner !cast<PointerType>(Ty)->getElementType()->isInteger() || 255b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 2563702d265b8278c4b67efb4989e6724205908addfReid Spencer TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first, LocalPrefix))); 257207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 258207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 259207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 260207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 261207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 262fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void calcTypeName(const Type *Ty, 2634ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::vector<const Type *> &TypeStack, 2644ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::map<const Type *, std::string> &TypeNames, 2654ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string & Result){ 26642a75517250017a52afb03a0ade03cbd49559fe5Chris Lattner if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) { 2674ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += Ty->getDescription(); // Base case 2684ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2694ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 270207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 271207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2727b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 2734ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (I != TypeNames.end()) { 2744ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += I->second; 2754ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2764ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 277207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2784ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (isa<OpaqueType>(Ty)) { 2794ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 2804ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2814ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 28288c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 283207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 284207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 285207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 286207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 287fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // This is another base case for the recursion. In this case, we know 288207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 289207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 2904ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Slot < CurSize) { 2914ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 2924ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2934ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 294207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 295207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 296fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 297f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 298a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case Type::IntegerTyID: { 299a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 30015ee935fc52b2e68a294631aac0c84ea4ba72509Reid Spencer Result += "i" + utostr(BitWidth); 301a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer break; 302a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer } 3036bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 304949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 3054ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 3064ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += " ("; 307d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 308dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands E = FTy->param_end(); I != E; ++I) { 309d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 310207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3114ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 312207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 3132761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 314d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 315207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 316207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 317207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 318207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 319207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 320207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 321949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 32238ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 32338ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Result += '<'; 3244ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "{ "; 325d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 326d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 327d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 328207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3294ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 330207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 331207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 33238ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 33338ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Result += '>'; 334207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 335207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 336fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb case Type::PointerTyID: { 337fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb const PointerType *PTy = cast<PointerType>(Ty); 338fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb calcTypeName(PTy->getElementType(), 3394ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell TypeStack, TypeNames, Result); 340fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb if (unsigned AddressSpace = PTy->getAddressSpace()) 341fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb Result += " addrspace(" + utostr(AddressSpace) + ")"; 3424ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "*"; 343207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 344fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb } 345207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 346949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 3474ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "[" + utostr(ATy->getNumElements()) + " x "; 3484ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 3494ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "]"; 350207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 351207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 3529d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer case Type::VectorTyID: { 3539d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer const VectorType *PTy = cast<VectorType>(Ty); 354715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += "<" + utostr(PTy->getNumElements()) + " x "; 355715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); 356715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += ">"; 357715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke break; 358715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 3599e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 3604ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 3619e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 362207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 3634ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "<unrecognized-type>"; 36482c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner break; 365207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 366207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 367207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 368207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 369207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 370207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3719d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 3729d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 3739d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 3747b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 3757b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 376207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 377207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 378207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 37942a75517250017a52afb03a0ade03cbd49559fe5Chris Lattner if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) 380daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 381207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 382207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 3837b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 384207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 385207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 386207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 387207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 388207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 389207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 3907b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 3914ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string TypeName; 3924ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(Ty, TypeStack, TypeNames, TypeName); 393697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 3944ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return (Out << TypeName); 395207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 396207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 397e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 3989d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 3999d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 4009d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 4019d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 40231f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 40331f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 404fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << ' '; 405207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 40682c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner // If they want us to print out a type, but there is no context, we can't 40782c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner // print it symbolically. 40882c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner if (!M) 4097b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 41082c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner 41182c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner std::map<const Type *, std::string> TypeNames; 41282c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner fillTypeNameTable(M, TypeNames); 41382c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner return printTypeInt(Out, Ty, TypeNames); 414207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 415207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 41618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// PrintEscapedString - Print each character of the specified string, escaping 41718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// it if it is not printable or if it is an escape char. 41818365506ebe3e28593cb36951f17f08e75712a29Chris Lattnerstatic void PrintEscapedString(const std::string &Str, std::ostream &Out) { 41918365506ebe3e28593cb36951f17f08e75712a29Chris Lattner for (unsigned i = 0, e = Str.size(); i != e; ++i) { 42018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner unsigned char C = Str[i]; 42118365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (isprint(C) && C != '"' && C != '\\') { 42218365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << C; 42318365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } else { 42418365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << '\\' 42518365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 42618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 42718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 42818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 42918365506ebe3e28593cb36951f17f08e75712a29Chris Lattner} 43018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 43182c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattnerstatic const char *getPredicateText(unsigned predicate) { 43281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer const char * pred = "unknown"; 43381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer switch (predicate) { 43481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_FALSE: pred = "false"; break; 43581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 43681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGT: pred = "ogt"; break; 43781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGE: pred = "oge"; break; 43881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLT: pred = "olt"; break; 43981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLE: pred = "ole"; break; 44081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ONE: pred = "one"; break; 44181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ORD: pred = "ord"; break; 44281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNO: pred = "uno"; break; 44381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 44481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGT: pred = "ugt"; break; 44581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGE: pred = "uge"; break; 44681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULT: pred = "ult"; break; 44781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULE: pred = "ule"; break; 44881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNE: pred = "une"; break; 44981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_TRUE: pred = "true"; break; 45081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_EQ: pred = "eq"; break; 45181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_NE: pred = "ne"; break; 45281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGT: pred = "sgt"; break; 45381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGE: pred = "sge"; break; 45481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLT: pred = "slt"; break; 45581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLE: pred = "sle"; break; 45681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGT: pred = "ugt"; break; 45781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGE: pred = "uge"; break; 45881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULT: pred = "ult"; break; 45981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULE: pred = "ule"; break; 46081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer } 46181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer return pred; 46281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer} 46381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer 464fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// @brief Internal constant writer. 465fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 4667b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 4670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 46838a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey const int IndentSize = 4; 46938a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey static std::string Indent = "\n"; 4706b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 4714fe16d607d11e29d742208894909733f5ad01f8fReid Spencer if (CI->getType() == Type::Int1Ty) 472579dca12c2cfd60bc18aaadbd5331897d48fec29Reid Spencer Out << (CI->getZExtValue() ? "true" : "false"); 473579dca12c2cfd60bc18aaadbd5331897d48fec29Reid Spencer else 474914c3bca870e448731b210b528a6a2f450ece772Reid Spencer Out << CI->getValue().toStringSigned(10); 47566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 4769d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble || 4779d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle) { 4789d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // We would like to output the FP constant value in exponential notation, 4799d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // but we cannot do this if doing so will lose precision. Check here to 4809d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // make sure that we only output it in exponential format if we can parse 4819d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // the value back and get the same value. 4829d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // 4839d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble; 4849d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen double Val = (isDouble) ? CFP->getValueAPF().convertToDouble() : 4859d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen CFP->getValueAPF().convertToFloat(); 4869d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen std::string StrVal = ftostr(CFP->getValueAPF()); 4879d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen 4889d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // Check to make sure that the stringized number is not some string like 4899d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // "Inf" or NaN, that atof will accept, but the lexer will not. Check 4909d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // that the string matches the "[-+]?[0-9]" regex. 4919d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // 4929d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 4939d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen ((StrVal[0] == '-' || StrVal[0] == '+') && 4949d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen (StrVal[1] >= '0' && StrVal[1] <= '9'))) { 4959d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // Reparse stringized version! 4969d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if (atof(StrVal.c_str()) == Val) { 4979d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << StrVal; 4989d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen return; 4999d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen } 50066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 5019d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // Otherwise we could not reparse it to exactly the same value, so we must 5029d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // output the string in hexadecimal format! 5039d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen assert(sizeof(double) == sizeof(uint64_t) && 5049d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen "assuming that double is 64 bits!"); 5059d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << "0x" << utohexstr(DoubleToBits(Val)); 5069d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen } else { 5079d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // Some form of long double. These appear as a magic letter identifying 5089d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen // the type, then a fixed number of hex digits. 5099d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << "0x"; 5109d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) 5119d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << 'K'; 5129d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) 5139d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << 'L'; 514a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) 515a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen Out << 'M'; 5169d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen else 5179d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen assert(0 && "Unsupported floating point type"); 518693717fbe6d4e0f63bb9927229e26851e4744530Dale Johannesen // api needed to prevent premature destruction 519693717fbe6d4e0f63bb9927229e26851e4744530Dale Johannesen APInt api = CFP->getValueAPF().convertToAPInt(); 520693717fbe6d4e0f63bb9927229e26851e4744530Dale Johannesen const uint64_t* p = api.getRawData(); 5219d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen uint64_t word = *p; 5229d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen int shiftcount=60; 523a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen int width = api.getBitWidth(); 5249d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen for (int j=0; j<width; j+=4, shiftcount-=4) { 5259d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen unsigned int nibble = (word>>shiftcount) & 15; 5269d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if (nibble < 10) 5279d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << (unsigned char)(nibble + '0'); 5289d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen else 5299d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen Out << (unsigned char)(nibble - 10 + 'A'); 53048325f4b0892859844f9dc0c6e9d2606e381ecc4Dale Johannesen if (shiftcount == 0 && j+4 < width) { 5319d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen word = *(++p); 532a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen shiftcount = 64; 5339d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen if (width-j-4 < 64) 5349d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen shiftcount = width-j-4; 5359d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen } 5369d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen } 5379d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen } 538de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 539de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 54066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 54166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 5429b38d7db6d9fbb5bf9d16bec590a17c5895453e1Dan Gohman // i8 with ConstantInt values. 543fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // 54466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 54518365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (CA->isString()) { 54666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 54718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner PrintEscapedString(CA->getAsString(), Out); 54866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 54966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 55066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 55140c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '['; 5527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 55340c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 55466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 5557a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 5562fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner TypeTable, Machine); 5577a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 5587a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 55966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 5602fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine); 5617a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5627a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5637a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 5647a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5657a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 56643f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth if (CS->getType()->isPacked()) 56743f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth Out << '<'; 56840c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '{'; 569a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey unsigned N = CS->getNumOperands(); 570a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey if (N) { 57138a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) { 57238a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Indent += std::string(IndentSize, ' '); 57338a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << Indent; 57438a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } else { 57538a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << ' '; 57638a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } 5777a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 5787a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5792fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine); 5807a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 581a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey for (unsigned i = 1; i < N; i++) { 5827a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 58338a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Out << Indent; 5847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 5857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5862fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine); 5877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 58838a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Indent.resize(Indent.size() - IndentSize); 5897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 590a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey 5917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 59243f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth if (CS->getType()->isPacked()) 59343f344a26695ba85a1a0b5407c038d9c3f980327Andrew Lenharth Out << '>'; 5949d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) { 595715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke const Type *ETy = CP->getType()->getElementType(); 596fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(CP->getNumOperands() > 0 && 597715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke "Number of operands for a PackedConst must be > 0"); 598715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << '<'; 599715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ' '; 600715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 6012fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine); 602715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { 603715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ", "; 604715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 6052fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine); 606715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 607715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << " >"; 6087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 6097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 6107a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 611b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner } else if (isa<UndefValue>(CV)) { 612b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner Out << "undef"; 613b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner 614c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 61581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << CE->getOpcodeName(); 61681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer if (CE->isCompare()) 61781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(CE->getPredicate()); 61881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " ("; 619fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 620b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 621b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 6222fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, *OI, TypeTable, Machine); 623b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 624c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 625b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 626fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 6273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (CE->isCast()) { 62895586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 62995586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 63095586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 6313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 63240c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ')'; 63395586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 6347a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 635b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 6367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 6387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 640ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 641ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 642ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 643ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 644fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 6457b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 6460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 64740c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 6482fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (V->hasName()) 6493702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << getLLVMName(V->getName(), 6503702d265b8278c4b67efb4989e6724205908addfReid Spencer isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix); 6517970396014eacbe719eb171448ddc546c1ad2289Reid Spencer else { 6527970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CV = dyn_cast<Constant>(V); 65380cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (CV && !isa<GlobalValue>(CV)) { 6542fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteConstantInt(Out, CV, TypeTable, Machine); 65580cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 65680cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "asm "; 65780cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (IA->hasSideEffects()) 65880cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "sideeffect "; 65980cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 66080cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getAsmString(), Out); 66180cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "\", \""; 66280cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getConstraintString(), Out); 66380cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 66480cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else { 6653702d265b8278c4b67efb4989e6724205908addfReid Spencer char Prefix = '%'; 6667a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 6670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine) { 6683702d265b8278c4b67efb4989e6724205908addfReid Spencer if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 66922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getGlobalSlot(GV); 6703702d265b8278c4b67efb4989e6724205908addfReid Spencer Prefix = '@'; 6713702d265b8278c4b67efb4989e6724205908addfReid Spencer } else { 67222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getLocalSlot(V); 6733702d265b8278c4b67efb4989e6724205908addfReid Spencer } 6747a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 6750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine = createSlotMachine(V); 67622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (Machine) { 6773702d265b8278c4b67efb4989e6724205908addfReid Spencer if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 67822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getGlobalSlot(GV); 6793702d265b8278c4b67efb4989e6724205908addfReid Spencer Prefix = '@'; 6803702d265b8278c4b67efb4989e6724205908addfReid Spencer } else { 68122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner Slot = Machine->getLocalSlot(V); 6823702d265b8278c4b67efb4989e6724205908addfReid Spencer } 68322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner } else { 68469566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = -1; 68522379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner } 686b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer delete Machine; 6877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 68869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 6893702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << Prefix << Slot; 69069566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 69169566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << "<badref>"; 6927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 6957a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6969d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 6979d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 6989d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 6999d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 70031f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 701a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner bool PrintType, const Module *Context) { 7027b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 703607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 7047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 7056e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 706607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 707207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 7087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 7097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 710fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 7112fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, V, TypeNames, 0); 712622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 713622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 714622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 7150e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 71631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 717d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 718007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 7190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman std::ostream &Out; 7200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine &Machine; 721c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 7227b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 72395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 724009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 7250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 72695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 7270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 728c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 729c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 730c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 731c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 732207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 733009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 734009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7358b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const Module *M) { printModule(M); } 7368b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const GlobalVariable *G) { printGlobal(G); } 7378b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const GlobalAlias *G) { printAlias(G); } 7388b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const Function *F) { printFunction(F); } 7398b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 7407e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 7418b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov inline void write(const Type *Ty) { printType(Ty); } 742009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7432fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner void writeOperand(const Value *Op, bool PrintType); 7440d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesen void writeParamOperand(const Value *Operand, ParameterAttributes Attrs); 74566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 7465cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 7475cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 748f771bea7402f05f59b2857586de9934ff1c7bbf5Misha Brukmanprivate: 749c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 75078d033e086e19e016273de014f9214aa6f3f844bReid Spencer void printTypeSymbolTable(const TypeSymbolTable &ST); 751c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 7528b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov void printAlias(const GlobalAlias *GV); 75379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 7540d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesen void printArgument(const Argument *FA, ParameterAttributes Attrs); 755c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 7567e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 7572761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7582761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 7592761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 7602761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 7617b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 7620313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return printTypeInt(Out, Ty, TypeNames); 7632761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7642761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7652761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 7662761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 7672761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 7687b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 769c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 770e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 771e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 7727e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 773009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 77473b7495a96e21e1515df86414e0636dbf1395fc5Reid Spencer} // end of llvm namespace 775009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 776ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 777ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 778ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7797b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 780a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 781a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer Out << "i" << utostr(ITy->getBitWidth()); 782a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer else if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 783bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer printType(FTy->getReturnType()); 784bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << " ("; 785d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 786d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 787d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 7880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 7897a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 7902761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7912761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 7920313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FTy->getNumParams()) Out << ", "; 7930313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; 7942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7950313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 7967e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 79738ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 79838ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Out << '<'; 7990313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "{ "; 800d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 801d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 802d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 8030313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 8042761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 8052761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 8060313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " }"; 80738ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth if (STy->isPacked()) 80838ecbf18eb9c8ca7ae08dfed4dc6fb4e3e5deb1eAndrew Lenharth Out << '>'; 8097e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 810ef989a275c1191f583178c6934f3594e7a9fd3a6Christopher Lamb printType(PTy->getElementType()); 811ef989a275c1191f583178c6934f3594e7a9fd3a6Christopher Lamb if (unsigned AddressSpace = PTy->getAddressSpace()) 812ef989a275c1191f583178c6934f3594e7a9fd3a6Christopher Lamb Out << " addrspace(" << AddressSpace << ")"; 813ef989a275c1191f583178c6934f3594e7a9fd3a6Christopher Lamb Out << '*'; 8147e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 8150313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '[' << ATy->getNumElements() << " x "; 81640c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(ATy->getElementType()) << ']'; 8179d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) { 8185527c0b6d1bda2c63212f91837792663469fd764Reid Spencer Out << '<' << PTy->getNumElements() << " x "; 8195527c0b6d1bda2c63212f91837792663469fd764Reid Spencer printType(PTy->getElementType()) << '>'; 8205527c0b6d1bda2c63212f91837792663469fd764Reid Spencer } 8213ed469ccd7b028a030b550d84b7336d146f5d8faReid Spencer else if (isa<OpaqueType>(Ty)) { 8220313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "opaque"; 8232761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 824b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 8250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<unknown derived type>"; 8262761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 8272761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 8280313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return Out; 8292761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 8302761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 8312761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 8322fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 8332fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (Operand == 0) { 834aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner Out << "<null operand!>"; 8352fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner } else { 8362fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner if (PrintType) { Out << ' '; printType(Operand->getType()); } 8372fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 838aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner } 839007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 840007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8410d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesenvoid AssemblyWriter::writeParamOperand(const Value *Operand, 8420d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesen ParameterAttributes Attrs) { 843dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands if (Operand == 0) { 844dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands Out << "<null operand!>"; 845dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands } else { 846dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands Out << ' '; 847dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // Print the type 848dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands printType(Operand->getType()); 849dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // Print parameter attributes list 850dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands if (Attrs != ParamAttr::None) 85158d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << ' ' << ParamAttr::getAsString(Attrs); 852dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // Print the operand 853dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 854dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands } 855dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands} 856007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 857c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 85831ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner if (!M->getModuleIdentifier().empty() && 859fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // Don't print the ID if it will start a new line (which would 86031ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner // require a comment char before it). 86131ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner M->getModuleIdentifier().find('\n') == std::string::npos) 86231ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 86331ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner 864cf7ff2b4c8c18d67aced9d7ba84482819b38a84bOwen Anderson if (!M->getDataLayout().empty()) 865d2f9e609aa40de7049ebb6f838e7ba6579e3fb6aChris Lattner Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 866cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (!M->getTargetTriple().empty()) 867c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 868fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 869cc041ba03aed685400197fb938b7a583713d25afChris Lattner if (!M->getModuleInlineAsm().empty()) { 87042a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // Split the string into lines, to make it easier to read the .ll file. 871cc041ba03aed685400197fb938b7a583713d25afChris Lattner std::string Asm = M->getModuleInlineAsm(); 87242a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t CurPos = 0; 87342a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t NewLine = Asm.find_first_of('\n', CurPos); 87442a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner while (NewLine != std::string::npos) { 87542a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // We found a newline, print the portion of the asm string from the 87642a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // last newline up to this newline. 87742a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "module asm \""; 87842a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 87942a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out); 88042a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "\"\n"; 88142a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner CurPos = NewLine+1; 88242a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner NewLine = Asm.find_first_of('\n', CurPos); 88342a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner } 88471cdba31774ce18ed32e89f1c6f7716ab923aa46Chris Lattner Out << "module asm \""; 88542a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); 88618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << "\"\n"; 88718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 88818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 88944da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the dependent libraries and emit them. 890cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LI = M->lib_begin(); 891cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LE = M->lib_end(); 892cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (LI != LE) { 893cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << "deplibs = [ "; 894cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner while (LI != LE) { 89544da7d79760998f9a70340b49a3811229838224dChris Lattner Out << '"' << *LI << '"'; 896c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer ++LI; 897cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner if (LI != LE) 898cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << ", "; 899c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer } 900c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << " ]\n"; 90183f6a77c8fc27eba21bca05be37663f3a6e123a1Reid Spencer } 902e59eaf407a675845e278c2769e3dbed9f1daae8cReid Spencer 90344da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the symbol table, emitting all named constants. 90478d033e086e19e016273de014f9214aa6f3f844bReid Spencer printTypeSymbolTable(M->getTypeSymbolTable()); 905fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 906d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 907d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner I != E; ++I) 9087e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 90969dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner 91069dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner // Output all aliases. 91169dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner if (!M->alias_empty()) Out << "\n"; 91269dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 91369dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner I != E; ++I) 91469dacfce54473414c1a863d19ab8f2785cd2a4f2Chris Lattner printAlias(I); 915007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 91644da7d79760998f9a70340b49a3811229838224dChris Lattner // Output all of the functions. 9177e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 9187e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 919009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 920009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 921c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 9223702d265b8278c4b67efb4989e6724205908addfReid Spencer if (GV->hasName()) Out << getLLVMName(GV->getName(), GlobalPrefix) << " = "; 923d70684f7585a85c4248c1c224059478108741c70Chris Lattner 924585e64e63e37eefaf8b7029247762e0fed20a983Bill Wendling if (!GV->hasInitializer()) { 925b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov switch (GV->getLinkage()) { 926b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 927b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 928b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov default: Out << "external "; break; 929585e64e63e37eefaf8b7029247762e0fed20a983Bill Wendling } 930585e64e63e37eefaf8b7029247762e0fed20a983Bill Wendling } else { 9314ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 932b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 933aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen case GlobalValue::CommonLinkage: Out << "common "; break; 934b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 935b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 936b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::AppendingLinkage: Out << "appending "; break; 937b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 938b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 939b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 940b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalLinkage: break; 9413c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman case GlobalValue::GhostLinkage: 942e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << "GhostLinkage not allowed in AsmWriter!\n"; 9433c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman abort(); 9444ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 9457f70559bc47877bafc6dfa92b7df6b64650445fbAnton Korobeynikov switch (GV->getVisibility()) { 9469a40c023ccfe28cbaf4f6b2c92f033f2d6536231Chris Lattner default: assert(0 && "Invalid visibility style!"); 9477f70559bc47877bafc6dfa92b7df6b64650445fbAnton Korobeynikov case GlobalValue::DefaultVisibility: break; 9487f70559bc47877bafc6dfa92b7df6b64650445fbAnton Korobeynikov case GlobalValue::HiddenVisibility: Out << "hidden "; break; 9496f9896fcc81a1128b5f436d1763cc6213745adf1Anton Korobeynikov case GlobalValue::ProtectedVisibility: Out << "protected "; break; 9507f70559bc47877bafc6dfa92b7df6b64650445fbAnton Korobeynikov } 9517f70559bc47877bafc6dfa92b7df6b64650445fbAnton Korobeynikov } 952c763552299165b88d34a7d4f2d76ff413cbc7f67Lauro Ramos Venancio 953c763552299165b88d34a7d4f2d76ff413cbc7f67Lauro Ramos Venancio if (GV->isThreadLocal()) Out << "thread_local "; 9540313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << (GV->isConstant() ? "constant " : "global "); 9557a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 956d70684f7585a85c4248c1c224059478108741c70Chris Lattner 9577970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (GV->hasInitializer()) { 9587970396014eacbe719eb171448ddc546c1ad2289Reid Spencer Constant* C = cast<Constant>(GV->getInitializer()); 9597970396014eacbe719eb171448ddc546c1ad2289Reid Spencer assert(C && "GlobalVar initializer isn't constant?"); 9602fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(GV->getInitializer(), false); 9617970396014eacbe719eb171448ddc546c1ad2289Reid Spencer } 9628b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 963fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb if (unsigned AddressSpace = GV->getType()->getAddressSpace()) 964fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb Out << " addrspace(" << AddressSpace << ") "; 965fe63fb986dc9510c5d68f2442edab9574e9e50d0Christopher Lamb 96660962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->hasSection()) 96760962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << ", section \"" << GV->getSection() << '"'; 96860962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->getAlignment()) 96930caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << ", align " << GV->getAlignment(); 9708b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 9717e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 9720313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 97370cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 97470cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 9758b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikovvoid AssemblyWriter::printAlias(const GlobalAlias *GA) { 9768b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << getLLVMName(GA->getName(), GlobalPrefix) << " = "; 9778b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov switch (GA->getVisibility()) { 9788b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov default: assert(0 && "Invalid visibility style!"); 9798b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov case GlobalValue::DefaultVisibility: break; 9808b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov case GlobalValue::HiddenVisibility: Out << "hidden "; break; 9816f9896fcc81a1128b5f436d1763cc6213745adf1Anton Korobeynikov case GlobalValue::ProtectedVisibility: Out << "protected "; break; 9828b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 9838b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 9848b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << "alias "; 9858b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 9868b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov switch (GA->getLinkage()) { 9878b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 9888b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 9898b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov case GlobalValue::ExternalLinkage: break; 9908b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov default: 9918b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov assert(0 && "Invalid alias linkage"); 9928b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 9938b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 994c6c98af9e5814e8066c82f20ca11cf646a5fc289Anton Korobeynikov const Constant *Aliasee = GA->getAliasee(); 9958b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 9968b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Aliasee)) { 9978b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov printType(GV->getType()); 9988b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << " " << getLLVMName(GV->getName(), GlobalPrefix); 9998b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } else if (const Function *F = dyn_cast<Function>(Aliasee)) { 10008b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov printType(F->getFunctionType()); 10018b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << "* "; 10028b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 10038b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov if (!F->getName().empty()) 10048b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << getLLVMName(F->getName(), GlobalPrefix); 10058b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov else 10068b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << "@\"\""; 1007591858a403a71fc5b30bc7b071f18bc0cf327cfcAnton Korobeynikov } else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(Aliasee)) { 1008591858a403a71fc5b30bc7b071f18bc0cf327cfcAnton Korobeynikov printType(GA->getType()); 1009591858a403a71fc5b30bc7b071f18bc0cf327cfcAnton Korobeynikov Out << " " << getLLVMName(GA->getName(), GlobalPrefix); 1010a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov } else { 1011a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov const ConstantExpr *CE = 0; 1012a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov if ((CE = dyn_cast<ConstantExpr>(Aliasee)) && 1013a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov (CE->getOpcode() == Instruction::BitCast)) { 1014a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov writeOperand(CE, false); 1015a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov } else 1016a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov assert(0 && "Unsupported aliasee"); 1017a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov } 1018a80e1181b78183dc36ec6568559d38faa86981f0Anton Korobeynikov 10198b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov printInfoComment(*GA); 10208b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov Out << "\n"; 10218b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov} 10228b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 102378d033e086e19e016273de014f9214aa6f3f844bReid Spencervoid AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) { 10249231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the types. 102578d033e086e19e016273de014f9214aa6f3f844bReid Spencer for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end(); 102678d033e086e19e016273de014f9214aa6f3f844bReid Spencer TI != TE; ++TI) { 10273702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << "\t" << getLLVMName(TI->first, LocalPrefix) << " = type "; 10289231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 10299231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Make sure we print out at least one level of the type structure, so 10309231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // that we do not get %FILE = type %FILE 10319231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 10329231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer printTypeAtLeastOneLevel(TI->second) << "\n"; 10339231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer } 103478d033e086e19e016273de014f9214aa6f3f844bReid Spencer} 103578d033e086e19e016273de014f9214aa6f3f844bReid Spencer 1036ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 1037ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 10387e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 1039009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 10400313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 10414ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 10420313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 104395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 10445cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (F->isDeclaration()) 10453aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner Out << "declare "; 10463aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner else 1047b951bc02839e9862e02e17c7ea83e6437fc13442Reid Spencer Out << "define "; 10483aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner 10493aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner switch (F->getLinkage()) { 10503aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::InternalLinkage: Out << "internal "; break; 10513aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 10523aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::WeakLinkage: Out << "weak "; break; 1053aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen case GlobalValue::CommonLinkage: Out << "common "; break; 10543aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::AppendingLinkage: Out << "appending "; break; 10553aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 10563aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 10573aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 10583aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::ExternalLinkage: break; 10593aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::GhostLinkage: 10603aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner cerr << "GhostLinkage not allowed in AsmWriter!\n"; 10613aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner abort(); 10623aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner } 10633aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner switch (F->getVisibility()) { 10643aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner default: assert(0 && "Invalid visibility style!"); 10653aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::DefaultVisibility: break; 10663aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::HiddenVisibility: Out << "hidden "; break; 10673aa6066d010b2ccfd58f07fb1be874becf5807c2Chris Lattner case GlobalValue::ProtectedVisibility: Out << "protected "; break; 1068b951bc02839e9862e02e17c7ea83e6437fc13442Reid Spencer } 10694ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 1070d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention. 1071d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (F->getCallingConv()) { 1072d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 1073f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Fast: Out << "fastcc "; break; 1074f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Cold: Out << "coldcc "; break; 1075f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1076f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1077d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << "cc" << F->getCallingConv() << " "; break; 1078d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1079d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 1080bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer const FunctionType *FT = F->getFunctionType(); 108158d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner const PAListPtr &Attrs = F->getParamAttrs(); 108240c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(F->getReturnType()) << ' '; 10834d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 10843702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << getLLVMName(F->getName(), GlobalPrefix); 10854d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 10863702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << "@\"\""; 10870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 10880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.incorporateFunction(F); 1089007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1090c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 1091007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1092bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer unsigned Idx = 1; 10938dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner if (!F->isDeclaration()) { 10948dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner // If this isn't a declaration, print the argument names as well. 10958dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 10968dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner I != E; ++I) { 10978dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 10988dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner if (I != F->arg_begin()) Out << ", "; 109958d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner printArgument(I, Attrs.getParamAttrs(Idx)); 11008dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner Idx++; 11018dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner } 11028dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner } else { 11038dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner // Otherwise, print the types from the function type. 11048dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 11058dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 11068dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner if (i) Out << ", "; 11078dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner 11088dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner // Output type... 11098dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner printType(FT->getParamType(i)); 11108dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner 111158d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner ParameterAttributes ArgAttrs = Attrs.getParamAttrs(i+1); 11128dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner if (ArgAttrs != ParamAttr::None) 111358d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << ' ' << ParamAttr::getAsString(ArgAttrs); 11148dcd2f1a5bbb9151ec05532861be58bf3f078e63Chris Lattner } 1115bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer } 1116007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1117007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 11187e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 11190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FT->getNumParams()) Out << ", "; 11200313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; // Output varargs portion of signature! 1121007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 11220313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 112358d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner ParameterAttributes RetAttrs = Attrs.getParamAttrs(0); 112458d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner if (RetAttrs != ParamAttr::None) 112558d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << ' ' << ParamAttr::getAsString(Attrs.getParamAttrs(0)); 112660962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (F->hasSection()) 112760962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << " section \"" << F->getSection() << '"'; 112830caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner if (F->getAlignment()) 112930caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << " align " << F->getAlignment(); 113080a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen if (F->hasCollector()) 113180a75bfae980df96f969f1c05b0c4a80ce975240Gordon Henriksen Out << " gc \"" << F->getCollector() << '"'; 113260962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner 11335cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (F->isDeclaration()) { 11340313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 113503e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 1136a1b5858fda38cfe5b30055a87020b6d5f7023238Chris Lattner Out << " {"; 1137fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1138b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 11397e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 11407e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 1141007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 11420313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "}\n"; 1143007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 1144007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 11450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.purgeFunction(); 1146009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1147009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1148ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 1149ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 1150ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 11510d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesenvoid AssemblyWriter::printArgument(const Argument *Arg, 11520d51e7ec0d2dcbea9e304fd58deb05f37eb75635Dale Johannesen ParameterAttributes Attrs) { 1153009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 1154c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 1155fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1156dc024674ff96820d6020757b48d47f46d4c07db2Duncan Sands // Output parameter attributes list 115718da0720887527ed570e9703ae5f290beb491ee1Reid Spencer if (Attrs != ParamAttr::None) 115858d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << ' ' << ParamAttr::getAsString(Attrs); 1159bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer 1160009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 1161009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 11623702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << ' ' << getLLVMName(Arg->getName(), LocalPrefix); 1163009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1164009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1165ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 1166ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 1167c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1168280a6e607d8eb7401749a92db624a82de47da777Nick Lewycky if (BB->hasName()) { // Print out the label if it exists... 1169280a6e607d8eb7401749a92db624a82de47da777Nick Lewycky Out << "\n" << getLLVMName(BB->getName(), LabelPrefix) << ':'; 1170280a6e607d8eb7401749a92db624a82de47da777Nick Lewycky } else if (!BB->use_empty()) { // Don't print block # of no uses... 117196c5b2f8c75b10f7e61ad90582d72c500d5c7d2dChris Lattner Out << "\n; <label>:"; 117222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int Slot = Machine.getLocalSlot(BB); 117369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 11740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << Slot; 117569566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 11760313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<badref>"; 1177061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 11784e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 11794e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 11800313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; Error: Block without parent!"; 1181eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block? 1182eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner // Output predecessors for the block... 1183eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner Out << "\t\t;"; 1184eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 1185eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner 1186eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner if (PI == PE) { 1187eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner Out << " No predecessors!"; 1188eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner } else { 1189eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner Out << " preds ="; 1190eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner writeOperand(*PI, false); 1191eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner for (++PI; PI != PE; ++PI) { 1192eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner Out << ','; 11932fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner writeOperand(*PI, false); 119440efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 1195061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 1196009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1197fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1198eb411291fa7614496ec8b51b0ced9f6cc2b78313Chris Lattner Out << "\n"; 1199009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 12000313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 120195e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 1202007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 12037e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 12047e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 12059f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 12060313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1207009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1208009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1209e02fa8551d20081534afa46e0976811687e5183aChris Lattner 1210ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 1211ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 1212ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 12137e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 12147e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 12150313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; <"; 121640c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(V.getType()) << '>'; 1217e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12187e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 121922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner int SlotNum; 122022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V)) 122122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner SlotNum = Machine.getGlobalSlot(GV); 122222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner else 122322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner SlotNum = Machine.getLocalSlot(&V); 122469566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (SlotNum == -1) 12250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ":<badref>"; 1226fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer else 12270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ':' << SlotNum; // Print out the def slot taken. 1228e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 12295c461404fed8d1def8eae02e6574bc5b16502575Chris Lattner Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses 1230e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1231e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 1232e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12333a9ec2463ddeba0820f284e2952bd6919cd5e080Reid Spencer// This member is called for each Instruction in a function.. 12347e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 12350313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 123695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 12370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t"; 1238009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1239009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 12407e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 12413702d265b8278c4b67efb4989e6724205908addfReid Spencer Out << getLLVMName(I.getName(), LocalPrefix) << " = "; 1242009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1243ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a volatile load or store, print out the volatile marker. 1244e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1245ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) { 12460313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "volatile "; 1247ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) { 1248ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a call, check if it's a tail call. 1249ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner Out << "tail "; 1250ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } 1251e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 1252009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 12530313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << I.getOpcodeName(); 1254009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 125574f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer // Print out the compare instruction predicates 1256ac80ade1580378e484e24c9f66d2fa5b058e5891Nate Begeman if (const CmpInst *CI = dyn_cast<CmpInst>(&I)) 1257ac80ade1580378e484e24c9f66d2fa5b058e5891Nate Begeman Out << " " << getPredicateText(CI->getPredicate()); 125874f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer 1259009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 12607e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1261009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1262009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 12637e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 12647e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 12650313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 1266009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 12670313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 12687e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 1269009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 127094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 1271009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 12720313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(Operand , true); Out << ','; 12730313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(1), true); Out << " ["; 1274009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 12757e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 12760313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t\t"; 12770313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), true); Out << ','; 12787e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 1279009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 12800313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t]"; 1281b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 12820313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 12837e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 12840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1285009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 12867e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 12870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (op) Out << ", "; 1288fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << '['; 12890313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), false); Out << ','; 12900313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op+1), false); Out << " ]"; 1291c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 1292d7313c560855555796a7a0e1ec39b7c2059e0542Devang Patel } else if (const GetResultInst *GRI = dyn_cast<GetResultInst>(&I)) { 1293377e04b926f187b036b7b7a536f69b6b5d5785e9Devang Patel writeOperand(I.getOperand(0), true); 1294d7313c560855555796a7a0e1ec39b7c2059e0542Devang Patel Out << ", " << GRI->getIndex(); 129557ef4f46c182cdbe014d469892090ff50c739cf9Devang Patel } else if (isa<ReturnInst>(I) && !Operand) { 129657ef4f46c182cdbe014d469892090ff50c739cf9Devang Patel Out << " void"; 1297d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1298d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1299d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (CI->getCallingConv()) { 1300d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 13010deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 13020deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1303b28a6dce6d57e05aa25520915726f82d2b3dc08dChris Lattner case CallingConv::X86_StdCall: Out << " x86_stdcallcc"; break; 1304b28a6dce6d57e05aa25520915726f82d2b3dc08dChris Lattner case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break; 1305d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << CI->getCallingConv(); break; 1306d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1307d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 1308b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const PointerType *PTy = cast<PointerType>(Operand->getType()); 1309b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1310b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const Type *RetTy = FTy->getReturnType(); 131158d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner const PAListPtr &PAL = CI->getParamAttrs(); 1312268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 13137a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 1314b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 13157a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 1316268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 13177a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1318fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 1319c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 13200313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 1321268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 1322268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 1323268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 1324268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 13250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 1326bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { 1327bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (op > 1) 1328bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << ','; 132958d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op)); 1330009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 13310313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )"; 133258d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner if (PAL.getParamAttrs(0) != ParamAttr::None) 133358d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0)); 13347e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 1335b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const PointerType *PTy = cast<PointerType>(Operand->getType()); 1336b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1337b138a0657f8739b6ddfeca296ff8c82ffa93b492Reid Spencer const Type *RetTy = FTy->getReturnType(); 133858d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner const PAListPtr &PAL = II->getParamAttrs(); 13397a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 1340d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1341d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (II->getCallingConv()) { 1342d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 13430deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 13440deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1345f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1346f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1347d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << II->getCallingConv(); break; 1348d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1349d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 13507a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 13517a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 13527a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 13537a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 13547a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1355fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 13567a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 13570313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 13587a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 13597a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 13607a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 13617a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 13627a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 13630313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 1364bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { 1365bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer if (op > 3) 1366bd5db8e29b82f864c3d6525c6cfefa557fafdbb8Reid Spencer Out << ','; 136758d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op-2)); 1368e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1369e02fa8551d20081534afa46e0976811687e5183aChris Lattner 13702c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << " )"; 137158d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner if (PAL.getParamAttrs(0) != ParamAttr::None) 137258d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner Out << " " << ParamAttr::getAsString(PAL.getParamAttrs(0)); 13732c261789d3f6826b42a010b8ff0115519ba31525Reid Spencer Out << "\n\t\t\tto"; 1374e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 13750313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " unwind"; 1376aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 1377e02fa8551d20081534afa46e0976811687e5183aChris Lattner 13787e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 13790313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 138094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 138194dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 13820313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 138394dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 1384009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 138514b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman if (AI->getAlignment()) { 13869fad0b9974beb76bef763b8fed71d0c8644403d4Chris Lattner Out << ", align " << AI->getAlignment(); 138714b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman } 1388e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 138941495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 13900313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " to "; 13917e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 13924d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 139341495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 13940313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 13958f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 1396009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 1397009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1398fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // PrintAllTypes - Instructions who have operands of all the same type 1399009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 1400009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 1401009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 1402009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 1403009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1404ebe57e36dff2dc3a7ceea99202bdb9eb6fe938bcReid Spencer // Select, Store and ShuffleVector always print all types. 14056494768ffcdf75e6e69a7955282db9ab9ab2e6fbDevang Patel if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I) 14066494768ffcdf75e6e69a7955282db9ab9ab2e6fbDevang Patel || isa<ReturnInst>(I)) { 1407ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 1408ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 1409ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1410ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 1411ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 1412ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 1413ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 1414ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 1415009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1416009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1417fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1418c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 14190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1420ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 1421c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 1422009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 14237e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 14240313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (i) Out << ','; 14257e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 1426009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1427009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 142843c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb 142943c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb // Print post operand alignment for load/store 143043c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb if (isa<LoadInst>(I) && cast<LoadInst>(I).getAlignment()) { 143143c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb Out << ", align " << cast<LoadInst>(I).getAlignment(); 143243c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb } else if (isa<StoreInst>(I) && cast<StoreInst>(I).getAlignment()) { 143343c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb Out << ", align " << cast<StoreInst>(I).getAlignment(); 143443c7f37942a35398fd1e14b22f435f483a0ee863Christopher Lamb } 1435009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1436e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 14370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1438009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1439009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1440009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1441009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1442009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 1443009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1444009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 144595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 14460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(this); 144795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 144875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1449009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1450009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 145175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 14520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 145395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 145475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1455b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 1456b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 14578b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikovvoid GlobalAlias::print(std::ostream &o) const { 14588b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov SlotMachine SlotTable(getParent()); 14598b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov AssemblyWriter W(o, SlotTable, getParent(), 0); 14608b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov W.write(this); 14618b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov} 14628b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 146395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 14640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 146595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 1466009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 146775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1468009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1469009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1470cc041ba03aed685400197fb938b7a583713d25afChris Lattnervoid InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 14712fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperand(o, this, true, 0); 1472cc041ba03aed685400197fb938b7a583713d25afChris Lattner} 1473cc041ba03aed685400197fb938b7a583713d25afChris Lattner 147495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 14750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 1476fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman AssemblyWriter W(o, SlotTable, 147795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 147875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 147975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1480009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 148195e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 148275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 14830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(F); 148495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1485009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 148675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 148775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1488009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 148975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 149075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 14913bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 149240c732cc52a5c71cead461646667ef5b13801923Misha Brukman o << ' ' << getType()->getDescription() << ' '; 1493a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng 1494a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng std::map<const Type *, std::string> TypeTable; 14952fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteConstantInt(o, this, TypeTable, 0); 1496009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1497009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1498fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanvoid Type::print(std::ostream &o) const { 149975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 150075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 150175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 150275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1503009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1504009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 150573e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 15062fcfdb79d0d1d2297d7aced11b567cd52494604eChris Lattner WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0); 150775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1508009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1509fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Value::dump - allow easy printing of Values from the debugger. 1510fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 1511832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendlingvoid Value::dump() const { print(*cerr.stream()); cerr << '\n'; } 1512fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer 1513fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Type::dump - allow easy printing of Values from the debugger. 1514fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 1515832171cb9724d2d31c8dfb73172e2be8f6dd13eeBill Wendlingvoid Type::dump() const { print(*cerr.stream()); cerr << '\n'; } 1516009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 151775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 151882c4bc7153d390ad1c2b369e0caef456948b8825Chris Lattner// SlotMachine Implementation 15190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 15200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#if 0 1522e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling#define SC_DEBUG(X) cerr << X 15230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#else 15240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) 15250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#endif 15260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Module level constructor. Causes the contents of the Module (sans functions) 15280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// to be added to the slot table. 1529fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanSlotMachine::SlotMachine(const Module *M) 1530b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule(M) ///< Saved for lazy initialization. 1531b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(0) 153228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 1533590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer , mMap(), mNext(0), fMap(), fNext(0) 15340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 15350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Function level constructor. Causes the contents of the Module and the one 15380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function provided to be added to the slot table. 1539c96ce89c97e1a051c00a169a46bac93838a82253Chris LattnerSlotMachine::SlotMachine(const Function *F) 1540c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization 1541b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(F) ///< Saved for lazy initialization 154228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 1543590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer , mMap(), mNext(0), fMap(), fNext(0) 15440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 1545b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer} 1546b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 154722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerinline void SlotMachine::initialize() { 1548c96ce89c97e1a051c00a169a46bac93838a82253Chris Lattner if (TheModule) { 1549fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processModule(); 1550b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheModule = 0; ///< Prevent re-processing next time we're called. 1551b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer } 1552de891a6c3583c47f0fd5d7b950f0fef3d06536e1Chris Lattner if (TheFunction && !FunctionProcessed) 1553fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processFunction(); 15540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Iterate through all the global variables, functions, and global 1557fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// variable initializers and create slots for them. 15580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::processModule() { 15590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processModule!\n"); 15600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1561a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all of the unnamed global variables to the value table. 1562d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner for (Module::const_global_iterator I = TheModule->global_begin(), 1563d6d826cdadc4dcaa5babefda85bf08aaa57d8bc5Chris Lattner E = TheModule->global_end(); I != E; ++I) 1564a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!I->hasName()) 15659446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateModuleSlot(I); 15660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1567a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all the unnamed functions to the table. 15680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 15690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 1570a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!I->hasName()) 15719446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateModuleSlot(I); 15720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processModule!\n"); 15740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1577b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// Process the arguments, basic blocks, and instructions of a function. 1578b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencervoid SlotMachine::processFunction() { 15790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processFunction!\n"); 1580590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer fNext = 0; 15810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1582a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all the function arguments with no names. 1583fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 1584e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner AE = TheFunction->arg_end(); AI != AE; ++AI) 1585a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!AI->hasName()) 15869446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(AI); 15870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("Inserting Instructions:\n"); 15890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1590a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner // Add all of the basic blocks and instructions with no names. 1591fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for (Function::const_iterator BB = TheFunction->begin(), 1592b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer E = TheFunction->end(); BB != E; ++BB) { 1593a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (!BB->hasName()) 15949446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(BB); 1595a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1596a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner if (I->getType() != Type::VoidTy && !I->hasName()) 15979446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner CreateFunctionSlot(I); 15980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 160028531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = true; 160128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer 16020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processFunction!\n"); 16030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 16040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1605de891a6c3583c47f0fd5d7b950f0fef3d06536e1Chris Lattner/// Clean up after incorporating a function. This is the only way to get out of 160622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// the function incorporation state that affects get*Slot/Create*Slot. Function 16073a4621c5f6e406da75c15e1351e2df5a7a4d9297Chris Lattner/// incorporation state is indicated by TheFunction != 0. 16080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::purgeFunction() { 16090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin purgeFunction!\n"); 16100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer fMap.clear(); // Simply discard the function level map 1611b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheFunction = 0; 161228531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 16130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end purgeFunction!\n"); 16140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 16150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 161622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// getGlobalSlot - Get the slot number of a global value. 161722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerint SlotMachine::getGlobalSlot(const GlobalValue *V) { 161822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Check for uninitialized state and do lazy initialization. 161922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner initialize(); 162022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 162122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Find the type plane in the module map 1622590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer ValueMap::const_iterator MI = mMap.find(V); 162322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (MI == mMap.end()) return -1; 1624590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer 1625590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer return MI->second; 162622379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner} 1627b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 162822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 162922379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner/// getLocalSlot - Get the slot number for a value that is local to a function. 163022379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattnerint SlotMachine::getLocalSlot(const Value *V) { 163122379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!"); 163222379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 163322379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner // Check for uninitialized state and do lazy initialization. 163422379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner initialize(); 16350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1636590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer ValueMap::const_iterator FI = fMap.find(V); 163722379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner if (FI == fMap.end()) return -1; 163822379bc7bb28fbfb1182877e6dc316aaab98a4baChris Lattner 1639590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer return FI->second; 16400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 16410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16420e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16439446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 16449446bbe7d4099eb5b917519d458a07ca08270471Chris Lattnervoid SlotMachine::CreateModuleSlot(const GlobalValue *V) { 1645cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner assert(V && "Can't insert a null Value into SlotMachine!"); 1646590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer assert(V->getType() != Type::VoidTy && "Doesn't need a slot!"); 1647590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer assert(!V->hasName() && "Doesn't need a slot!"); 1648cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 1649590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer unsigned DestSlot = mNext++; 1650590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer mMap[V] = DestSlot; 1651cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 1652590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer SC_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << 1653cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner DestSlot << " ["); 16548b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov // G = Global, F = Function, A = Alias, o = other 16558b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 16568b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov (isa<Function> ? 'F' : 16578b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov (isa<GlobalAlias> ? 'A' : 'o'))) << "]\n"); 16589446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner} 16599446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 16609446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner 16613a4621c5f6e406da75c15e1351e2df5a7a4d9297Chris Lattner/// CreateSlot - Create a new slot for the specified value if it has no name. 16629446bbe7d4099eb5b917519d458a07ca08270471Chris Lattnervoid SlotMachine::CreateFunctionSlot(const Value *V) { 16639446bbe7d4099eb5b917519d458a07ca08270471Chris Lattner const Type *VTy = V->getType(); 1664a6b1ffcfaaaf698386243a36992193a3c2c86766Chris Lattner assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!"); 1665cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 1666590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer unsigned DestSlot = fNext++; 1667590b3c559fd7ca42e3d8c21e834481b0ff12c1a1Reid Spencer fMap[V] = DestSlot; 1668cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner 16694932a5a3350a28a7cb41972036d6576401cc1b01Chris Lattner // G = Global, F = Function, o = other 1670cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1671cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner DestSlot << " [o]\n"); 1672cf8790aaff0ed1b7aead5b922450352d72c301bfChris Lattner} 1673