AsmWriter.cpp revision 73b7495a96e21e1515df86414e0636dbf1395fc5
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 1202b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// Note that these routines must be extremely tolerant of various errors in the 138f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner// LLVM code, because it can be used for debugging transformations. 1402b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 15009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 16009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 17da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 1875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 19f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 2095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner#include "llvm/Assembly/AsmAnnotationWriter.h" 21f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Constants.h" 223eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 23b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 24009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 25e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 267061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 277061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 28f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Module.h" 29007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 305cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman#include "llvm/Assembly/Writer.h" 31061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner#include "llvm/Support/CFG.h" 32cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 33cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 34007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 3531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 36d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencernamespace { 380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// This class provides computation of slot numbers for LLVM Assembly writing. 400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @brief LLVM Assembly Writing Slot Computation. 410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerclass SlotMachine { 420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Types 440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A mapping of Values to slot numbers 480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer typedef std::map<const Value*, unsigned> ValueMap; 490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A plane with next slot number and ValueMap 510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer struct Plane { 520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned next_slot; ///< The next slot number to use 530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap map; ///< The map of Value* -> unsigned 540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Plane() { next_slot = 0; } ///< Make sure we start at 0 550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer }; 560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The map of planes by Type 580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer typedef std::map<const Type*, Plane> TypedPlanes; 590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Constructors 620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a module 650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Module *M ); 660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a function, starting out in incorp state. 680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Function *F ); 690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Accessors 720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Return the slot number of the specified value in it's type 750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// plane. Its an error to ask for something not in the SlotMachine. 760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Its an error to ask for a Type* 77b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer unsigned getSlot(const Value *V) ; 780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Mutators 810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// If you'd like to deal with a function instead of just a module, use 840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// this method to get its data into the SlotMachine. 85b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void incorporateFunction(const Function *F) { TheFunction = F; } 860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// After calling incorporateFunction, use this method to remove the 880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// most recently incorporated function from the SlotMachine. This 890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// will reset the state of the machine back to just the module contents. 900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void purgeFunction(); 910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Implementation Details 940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerprivate: 96b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// This function does the actual initialization. 97b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer inline void initialize(); 98b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Values can be crammed into here at will. If they haven't 1000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// been inserted already, they get inserted, otherwise they are ignored. 1010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Either way, the slot number for the Value* is returned. 1020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned createSlot(const Value *V); 1030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Insert a value into the value table. Return the slot number 1050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// that it now occupies. BadThings(TM) will happen if you insert a 1060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Value that's already been inserted. 1070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned insertValue( const Value *V ); 1080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Add all of the module level global variables (and their initializers) 1100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// and function declarations, but not the contents of those functions. 1110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void processModule(); 1120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 113b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// Add all of the functions arguments, basic blocks, and instructions 114b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void processFunction(); 115b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 1170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void operator=(const SlotMachine &); // DO NOT IMPLEMENT 1180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Data 1210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 1230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The module for which we are holding slot numbers 125b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Module* TheModule; 1260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 127b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// @brief The function for which we are holding slot numbers 128b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Function* TheFunction; 1290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the module level data 1310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes mMap; 1320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the function level data 1340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes fMap; 1350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer}; 1390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 1410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 142a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintModulePass> 143a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerX("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 144a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintFunctionPass> 145a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerY("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 146f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 1477b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 1487b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 1497b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 1500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine); 1517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 152207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 153949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 154207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 155949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 156207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 157949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 15879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 159207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 160949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 161207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 162207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 163207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 164207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerstatic SlotMachine *createSlotMachine(const Value *V) { 166c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner assert(!isa<Type>(V) && "Can't create an SC for a type!"); 167949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 1680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(FA->getParent()); 169949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 1700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(I->getParent()->getParent()); 171949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 1720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(BB->getParent()); 173949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 1740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(GV->getParent()); 175949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 1760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(Func); 177c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 178c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 179c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 180009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 18124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 18224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 18324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 18424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattnerstatic std::string getLLVMName(const std::string &Name) { 18524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 18624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 18724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 18824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 18924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 19024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 19124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 19224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 19324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 19424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 19524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 19624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 19724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 19824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 19924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 20024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 20124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "%"+Name; 20224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 20324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 204207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 205ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 206ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 207ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 208207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 2097b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 2106e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 2116e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 2129231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::type_const_iterator TI = ST.type_begin(); 2139231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; TI != ST.type_end(); ++TI ) { 2149231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // As a heuristic, don't insert pointer to primitive types, because 2159231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // they are used too often to have a single useful name. 2169231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 2179231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Type *Ty = cast<Type>(TI->second); 2189231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer if (!isa<PointerType>(Ty) || 219b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 220b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 2219231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 222207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 223207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 224207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 225207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 226207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2277b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::string calcTypeName(const Type *Ty, 2287b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> &TypeStack, 2297b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames){ 23088c17380646dbb7c0c5054a392de5a46d17620baChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 23188c17380646dbb7c0c5054a392de5a46d17620baChris Lattner return Ty->getDescription(); // Base case 232207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 233207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2347b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 235207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return I->second; 236207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 23788c17380646dbb7c0c5054a392de5a46d17620baChris Lattner if (isa<OpaqueType>(Ty)) 23888c17380646dbb7c0c5054a392de5a46d17620baChris Lattner return "opaque"; 23988c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 240207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 241207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 242207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 243207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 244207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 245207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 246207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 247207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (Slot < CurSize) 248207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return "\\" + utostr(CurSize-Slot); // Here's the upreference 249207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 250207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 251207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2527b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string Result; 253207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner switch (Ty->getPrimitiveID()) { 2546bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 255949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 2562761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; 257d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 258d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 259d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 260207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 261207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 262207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 2632761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 264d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 265207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 266207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 267207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 268207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 269207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 270207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 271949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 272207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result = "{ "; 273d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 274d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 275d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 276207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 277207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(*I, TypeStack, TypeNames); 278207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 279207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 280207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 281207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 282207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 283949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner Result = calcTypeName(cast<PointerType>(Ty)->getElementType(), 28402b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner TypeStack, TypeNames) + "*"; 285207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 286207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 287949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 288ff5c296498b3b1182e8d5e2515d0c15a7b558d4bChris Lattner Result = "[" + utostr(ATy->getNumElements()) + " x "; 289207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 290207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 291207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 2929e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 2939e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner Result = "opaque"; 2949e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 295207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 296b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Result = "<unrecognized-type>"; 297207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 298207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 299207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 300207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Result; 301207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 302207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 303207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3049d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 3059d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 3069d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 3077b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 3087b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 309207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 310207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 311207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 312daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 313daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 314207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 315207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 3167b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 317207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 318207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 319207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 320207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 321207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 322207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 3237b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 3247b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 325697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 326207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return Out << TypeName; 327207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 328207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 329e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 3309d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 3319d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 3329d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 3339d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 33431f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 33531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 336207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Out << " "; 337207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 338207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 339207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 3406e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 3417b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 342207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 343207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3447b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 345207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 3467b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 347207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 348207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 349207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3507b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 3517b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 3527b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 3530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 35466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 35566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << (CB == ConstantBool::True ? "true" : "false"); 35666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 35766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 35866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 35966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 36066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 36166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 36266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 36366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 36466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 36566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 36666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 36766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 36866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 36966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 37066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 37166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 37266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 37366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 374b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 37566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 37666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 37766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << StrVal; return; 37866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 37966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 38066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 38166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 38266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 38366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Behave nicely in the face of C TBAA rules... see: 38466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // http://www.nullstone.com/htmls/category/aliastyp.htm 38566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 38666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner double Val = CFP->getValue(); 38766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner char *Ptr = (char*)&Val; 38866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 38966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 39066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "0x" << utohexstr(*(uint64_t*)Ptr); 39166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 392de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 393de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 39466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 39566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 39666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 39766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 39866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 39966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 40066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 40166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (ETy == Type::SByteTy) 40266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) 40366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 40466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner isString = false; 40566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner break; 40666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 40766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 40866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (isString) { 40966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 41066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 411c07736a397012499e337c994f7f952b07c709544Chris Lattner unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue(); 41266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 413fc94446777fcdff03fdc09539bab25200936b43eChris Lattner if (isprint(C) && C != '"' && C != '\\') { 41466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << C; 41566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 41666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << '\\' 41766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 41866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 41966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 42066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 42166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 42266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 42366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 4247a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "["; 4257a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 4267a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 42766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4287a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 4290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4307a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 4317a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 43266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4337a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 4340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypeTable, Machine); 4357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 4387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 4407a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "{"; 4417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CS->getNumOperands()) { 4427a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 4437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 4447a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 4460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4477a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4487a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1; i < CS->getNumOperands(); i++) { 4497a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 4507a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 4517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 4530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4547a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4557a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4567a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4577a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 4587a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 4597a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 4607a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4617e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { 4620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteAsOperandInternal(Out, PR->getValue(), true, TypeTable, Machine); 463b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 464c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 46538d877365030f90b099d53ab6a66bd62271e330fChris Lattner Out << CE->getOpcodeName() << " ("; 466b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 467b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 468b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 4690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine); 470b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 471c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 472b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 473b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 4741c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner if (CE->getOpcode() == Instruction::Cast) { 47595586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 47695586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 47795586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 4781c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner Out << ")"; 47995586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 4807a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 481b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 4827a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4837a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 4847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 486ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 487ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 488ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 489ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 4907b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 4917b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 4927b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 4930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 4947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " "; 4957a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintName && V->hasName()) { 49624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 4977a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 498949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CV = dyn_cast<Constant>(V)) { 4990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteConstantInt(Out, CV, PrintName, TypeTable, Machine); 5007a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 5017a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 5020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine) { 503b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer Slot = Machine->getSlot(V); 5047a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 505949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Type *Ty = dyn_cast<Type>(V)) { 5067a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << Ty->getDescription(); 5077a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner return; 5087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5097a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine = createSlotMachine(V); 5110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine == 0) { Out << "BAD VALUE TYPE!"; return; } 5127a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 513b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer Slot = Machine->getSlot(V); 514b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer delete Machine; 5157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Out << "%" << Slot; 5177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 5207a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5217a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5229d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 5239d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 5249d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 5259d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 52631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 5279d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman bool PrintType, bool PrintName, 5289d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman const Module *Context) { 5297b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 530607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 5317a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5326e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 533607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 534207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 5357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 5367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 5377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 538cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke if (const Type *Ty = dyn_cast<Type> (V)) 539cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke printTypeInt(Out, Ty, TypeNames); 540cd4a398c25a72ff307b48b78f813bb23e7a3a9caBrian Gaeke 541607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 542622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 543622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 544622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 54531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 546d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 547007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 548e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman std::ostream *Out; 5490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine &Machine; 550c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 5517b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 55295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 553009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 5540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 55595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 5560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer : Out(&o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 557c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 558c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 559c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 560c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 561207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 562009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 563009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 564c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 565c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 56679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 567c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 5687e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 569e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 570da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 571009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 57266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 57366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 5745cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 575e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman void setStream(std::ostream &os) { Out = &os; } 5765cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 577009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 578c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 579c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 580e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 581c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 58279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 58373e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 584c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 5857e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 5862761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5872761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 5882761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 5892761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 5907b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 591e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman return printTypeInt(*Out, Ty, TypeNames); 5922761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 5932761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 5942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 5952761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 5962761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 5977b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 598c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 599e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 600e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 6017e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 602009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 60373b7495a96e21e1515df86414e0636dbf1395fc5Reid Spencer} // end of llvm namespace 604009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 605ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 606ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 607ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 6087b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 6097e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 6102761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 611d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 612d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 613d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 614e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 6157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 6162761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 6172761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 618e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (FTy->getNumParams()) *Out << ", "; 619e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "..."; 6202761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 621e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ")"; 6227e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 623e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "{ "; 624d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 625d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 626d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 627e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 6282761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 6292761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 630e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " }"; 6317e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 6322761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(PTy->getElementType()) << "*"; 6337e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 634e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "[" << ATy->getNumElements() << " x "; 6352761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(ATy->getElementType()) << "]"; 6367e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 637e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "opaque"; 6382761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 639b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 640e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "<unknown derived type>"; 6412761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 6422761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 643e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman return *Out; 6442761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 6452761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6462761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 647007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 648b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer bool PrintName) { 649e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (PrintType) { *Out << " "; printType(Operand->getType()); } 6500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteAsOperandInternal(*Out, Operand, PrintName, TypeNames, &Machine); 651007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 652007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 653007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 654c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 655eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getEndianness()) { 656e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::LittleEndian: *Out << "target endian = little\n"; break; 657e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::BigEndian: *Out << "target endian = big\n"; break; 658eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyEndianness: break; 659eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 660eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getPointerSize()) { 661e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::Pointer32: *Out << "target pointersize = 32\n"; break; 662e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case Module::Pointer64: *Out << "target pointersize = 64\n"; break; 663eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyPointerSize: break; 664eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 665eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner 666007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 6676e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 66870cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 6697e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 6707e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 671007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 672e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\nimplementation ; Functions:\n"; 6735efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 674b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of the functions... 6757e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 6767e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 677009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 678009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 679c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 680e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (GV->hasName()) *Out << getLLVMName(GV->getName()) << " = "; 681d70684f7585a85c4248c1c224059478108741c70Chris Lattner 6824ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!GV->hasInitializer()) 683e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "external "; 6844ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 6854ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 686e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::InternalLinkage: *Out << "internal "; break; 687e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 688e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::WeakLinkage: *Out << "weak "; break; 689e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::AppendingLinkage: *Out << "appending "; break; 6904ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 6914ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 692d70684f7585a85c4248c1c224059478108741c70Chris Lattner 693e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << (GV->isConstant() ? "constant " : "global "); 6947a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 695d70684f7585a85c4248c1c224059478108741c70Chris Lattner 696d70684f7585a85c4248c1c224059478108741c70Chris Lattner if (GV->hasInitializer()) 697d70684f7585a85c4248c1c224059478108741c70Chris Lattner writeOperand(GV->getInitializer(), false, false); 698d70684f7585a85c4248c1c224059478108741c70Chris Lattner 6997e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 700e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 70170cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 70270cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 703009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7049231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// printSymbolTable - Run through symbol table looking for constants 7059231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// and types. Emit their declarations. 706c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 7079231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7089231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the types. 7099231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::type_const_iterator TI = ST.type_begin(); 7109231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TI != ST.type_end(); ++TI ) { 7119231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer *Out << "\t" << getLLVMName(TI->first) << " = type "; 7129231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7139231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Make sure we print out at least one level of the type structure, so 7149231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // that we do not get %FILE = type %FILE 7159231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 7169231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer printTypeAtLeastOneLevel(TI->second) << "\n"; 7179231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer } 718007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 7199231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the constants, in type plane order. 7209231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 7219231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer PI != ST.plane_end(); ++PI ) { 7229231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 7239231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 7249231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7259231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; VI != VE; ++VI) { 7269231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Value *V = VI->second; 727949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Constant *CPV = dyn_cast<Constant>(V)) { 728b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer printConstant(CPV); 729007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 730007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 731739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 732009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 733009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 734009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 735ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printConstant - Print out a constant pool entry... 736ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 737e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 738007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 739007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 740009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7411333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 742e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t" << getLLVMName(CPV->getName()) << " ="; 743009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 744009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 7457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 746009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7477e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 748e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 749009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 750009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 751ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 752ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7537e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 754009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 755e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 7564ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 757e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, *Out); 75895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 7594ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 760e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "declare "; 7614ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 7624ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 763e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::InternalLinkage: *Out << "internal "; break; 764e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 765e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::WeakLinkage: *Out << "weak "; break; 766e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman case GlobalValue::AppendingLinkage: *Out << "appending "; break; 7674ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 7684ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 7694ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 770b8565e3918d2e5d43a8e53f545a8a1c587582fd3Chris Lattner printType(F->getReturnType()) << " "; 7714d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 772e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << getLLVMName(F->getName()); 7734d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 774e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\"\""; 775e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 7760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.incorporateFunction(F); 777007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 778c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 7797e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 780007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 78169da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 78269da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 783007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 784007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 7857e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 786e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (FT->getNumParams()) *Out << ", "; 787e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "..."; // Output varargs portion of signature! 788007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 789e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ")"; 790007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 7917e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 792e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 79303e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 794e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " {"; 795007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 796b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 7977e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 7987e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 799007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 800e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "}\n"; 801007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 802007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.purgeFunction(); 804009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 805009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 806ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 807ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 808ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 80973e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 810009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 811e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (Arg != &Arg->getParent()->afront()) *Out << ", "; 812009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 813009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 814c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 815009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 816009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 817009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 818e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " " << getLLVMName(Arg->getName()); 819009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 820009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 821ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 822ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 823c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 824009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 825e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n" << BB->getName() << ":"; 826afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 8270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer *Out << "\n; <label>:" << Machine.getSlot(BB); 828061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 8294e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 8304e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 831e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t; Error: Block without parent!"; 8324e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner else { 8334e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB != &BB->getParent()->front()) { // Not the entry block? 8344e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner // Output predecessors for the block... 835e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t;"; 8364e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 8374e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 8384e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (PI == PE) { 839e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " No predecessors!"; 8404e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } else { 841e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " preds ="; 84240efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner writeOperand(*PI, false, true); 8434e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner for (++PI; PI != PE; ++PI) { 844e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 8454e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner writeOperand(*PI, false, true); 8464e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } 84740efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 848061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 849009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 850afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner 851e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 852009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 853e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, *Out); 85495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 855007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 8567e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 8577e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 8589f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 859e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, *Out); 860009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 861009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 862e02fa8551d20081534afa46e0976811687e5183aChris Lattner 863ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 864ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 865ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 8667e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 8677e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 868e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t\t; <"; 8697e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(V.getType()) << ">"; 870e02fa8551d20081534afa46e0976811687e5183aChris Lattner 8717e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 8720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer *Out << ":" << Machine.getSlot(&V); // Print out the def slot taken. 873e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 874e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " [#uses=" << V.use_size() << "]"; // Output # uses 875e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 876e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 877e02fa8551d20081534afa46e0976811687e5183aChris Lattner 878ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInstruction - This member is called for each Instruction in a method. 879ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 8807e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 881e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, *Out); 88295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 883e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\t"; 884009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 885009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 8867e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 887e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << getLLVMName(I.getName()) << " = "; 888009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 889e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner // If this is a volatile load or store, print out the volatile marker 890e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 891e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) 892e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "volatile "; 893e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 894009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 895e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << I.getOpcodeName(); 896009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 897009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 8987e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 899009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 900009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 9017e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 9027e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 903e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 904009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 905e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 9067e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 907009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 90894dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 909009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 910e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(Operand , true); *Out << ","; 911e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(1), true); *Out << " ["; 912009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9137e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 914e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n\t\t"; 915e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op ), true); *Out << ","; 9167e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 917009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 918e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n\t]"; 919b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 920e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 9217e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 922e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 923009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9247e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 925e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (op) *Out << ", "; 926e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "["; 927e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op ), false); *Out << ","; 928e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman writeOperand(I.getOperand(op+1), false); *Out << " ]"; 929c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 930e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 931e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " void"; 932e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 9337a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 9347a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 9357a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 936268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 9377a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 938b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 9397a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 940268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 9417a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 94294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner (!isa<PointerType>(RetTy) || 943c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 944e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; printType(RetTy); 945268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 946268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 947268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 948268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 949e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 9507e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 9517e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 952e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 9537e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 954009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 955009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 956e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " )"; 9577e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 9587a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 9597a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 9607a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 9617a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 9627a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 9637a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 9647a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 9657a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 9667a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 9677a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner (!isa<PointerType>(RetTy) || 9687a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 969e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; printType(RetTy); 9707a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 9717a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 9727a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 9737a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 9747a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 975e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "("; 9767e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 9777e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 978e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 9797e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 980e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 981e02fa8551d20081534afa46e0976811687e5183aChris Lattner 982e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " )\n\t\t\tto"; 983e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 984e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " unwind"; 985aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 986e02fa8551d20081534afa46e0976811687e5183aChris Lattner 9877e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 988e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 98994dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 99094dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 991e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ","; 99294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 993009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 994e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 99541495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 996e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " to "; 9977e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 9984d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 99941495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 1000e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 10018f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 10024d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) { 100341495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 1004e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << ", "; 10054d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner printType(VAN->getArgType()); 1006009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 1007009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1008009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 1009009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 1010009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 1011009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 1012009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 1013009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1014cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // Shift Left & Right print both types even for Ubyte LHS, and select prints 1015cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // types even if all operands are bools. 1016cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner if (isa<ShiftInst>(I) || isa<SelectInst>(I)) { 1017ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 1018ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 1019ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1020ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 1021ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 1022ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 1023ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 1024ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 1025009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1026009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1027ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner 1028c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 1029e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << " "; 1030ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 1031c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 1032009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 10337e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 1034e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (i) *Out << ","; 10357e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 1036009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1037009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1038009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1039e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 1040e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman *Out << "\n"; 1041009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1042009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1043009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1044009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1045009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 1046009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1047009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 104895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 10490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(this); 105095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 105175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1052009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1053009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 105475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 10550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 105695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 105775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1058b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 1059b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 106095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 10610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 106295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 1063009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 106475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1065009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1066009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 106795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 10680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 106975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, 107095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 107175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 107275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1073009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 107495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 107575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 10760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(F); 107795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1078009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 107975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 108075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1081009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 108275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 108375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 10843bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 10853bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner // Handle CPR's special, because they have context information... 10863bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { 10873bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner CPR->getValue()->print(o); // Print as a global value, with context info. 10883bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner return; 10893bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner } 10903bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 109166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner o << " " << getType()->getDescription() << " "; 109266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 10937b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeTable; 109466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner WriteConstantInt(o, this, false, TypeTable, 0); 1095009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1096009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 109775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Type::print(std::ostream &o) const { 109875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 109975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 110075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 110175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1102009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1103009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 110473e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 110575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getType() << " " << getName(); 110675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1107009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1108fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Value::dump - allow easy printing of Values from the debugger. 1109fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 111075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Value::dump() const { print(std::cerr); } 1111fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer 1112fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Type::dump - allow easy printing of Values from the debugger. 1113fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 11149231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencervoid Type::dump() const { print(std::cerr); } 1115009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 111675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 111775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 111875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 1119da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1120da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 1121da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 1122da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 11230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC = new SlotMachine(M ); 11245cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman AW = new AssemblyWriter(*Out, *SC, M, 0); 1125da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 1126da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 1127da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1128da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1129da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1130da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 1131da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 1132da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 1133da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1134da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1135da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter &CachedWriter::operator<<(const Value *V) { 1136da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 1137da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner switch (V->getValueType()) { 1138da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::ConstantVal: 113966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner case Value::ArgumentVal: AW->writeOperand(V, true, true); break; 1140949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner case Value::TypeVal: AW->write(cast<Type>(V)); break; 1141da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 1142da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 114379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner case Value::FunctionVal: AW->write(cast<Function>(V)); break; 1144da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 11455cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman default: *Out << "<unknown value type: " << V->getValueType() << ">"; break; 1146da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1147da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 1148da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 11495cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 11505cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha BrukmanCachedWriter& CachedWriter::operator<<(const Type *X) { 11515cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (SymbolicTypes) { 11525cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module *M = AW->getModule(); 11535cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (M) WriteTypeSymbolic(*Out, X, M); 11545cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman return *this; 11555cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman } else 11565cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman return *this << (const Value*)X; 11575cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman} 1158e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman 1159e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukmanvoid CachedWriter::setStream(std::ostream &os) { 1160e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman Out = &os; 1161e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman if (AW) AW->setStream(os); 1162e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman} 11639231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 11640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 11650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===-- SlotMachine Implementation 11660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 11670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 11680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#if 0 11690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) std::cerr << X 11700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#else 11710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) 11720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#endif 11730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 11740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Module level constructor. Causes the contents of the Module (sans functions) 11750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// to be added to the slot table. 11760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid SpencerSlotMachine::SlotMachine(const Module *M) 1177b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule(M) ///< Saved for lazy initialization. 1178b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(0) 11790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 11800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 11810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 11820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 11830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 11840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Function level constructor. Causes the contents of the Module and the one 11850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function provided to be added to the slot table. 11860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid SpencerSlotMachine::SlotMachine(const Function *F ) 1187b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization 1188b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(F) ///< Saved for lazy initialization 11890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 11900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 11910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 1192b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer} 1193b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1194b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencerinline void SlotMachine::initialize(void) { 1195b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheModule) { 1196b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer processModule(); 1197b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheModule = 0; ///< Prevent re-processing next time we're called. 1198b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer } 1199b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 1200b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer processFunction(); 12010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 12020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Iterate through all the global variables, functions, and global 12050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// variable initializers and create slots for them. 12060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::processModule() { 12070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processModule!\n"); 12080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the global variables to the value table... 12100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend(); 12110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 12120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 12130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the functions to the table 12150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 12160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 12170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 12180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processModule!\n"); 12200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1223b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// Process the arguments, basic blocks, and instructions of a function. 1224b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencervoid SlotMachine::processFunction() { 12250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processFunction!\n"); 12260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the function arguments 1228b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer for(Function::const_aiterator AI = TheFunction->abegin(), 1229b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer AE = TheFunction->aend(); AI != AE; ++AI) 12300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(AI); 12310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("Inserting Instructions:\n"); 12330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the basic blocks and instructions 1235b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer for (Function::const_iterator BB = TheFunction->begin(), 1236b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer E = TheFunction->end(); BB != E; ++BB) { 12370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(BB); 12380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 12390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 12400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 12410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 12420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processFunction!\n"); 12440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Clean up after incorporating a function. This is the only way 1247b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// to get out of the function incorporation state that affects the 1248b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// getSlot/createSlot lock. Function incorporation state is indicated 1249b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// by TheFunction != 0. 12500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::purgeFunction() { 12510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin purgeFunction!\n"); 12520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer fMap.clear(); // Simply discard the function level map 1253b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheFunction = 0; 12540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end purgeFunction!\n"); 12550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Get the slot number for a value. This function will assert if you 12580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// ask for a Value that hasn't previously been inserted with createSlot. 12590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Types are forbidden because Type does not inherit from Value (any more). 1260b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencerunsigned SlotMachine::getSlot(const Value *V) { 12610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't get slot for null Value" ); 12620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( !isa<Type>(V) && "Can't get slot for a type" ); 1263b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1264b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 1265b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1266b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Check for uninitialized state and do lazy initialization 1267b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer this->initialize(); 12680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Do not number CPR's at all. They are an abomination 12700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(V) ) 12710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer V = CPR->getValue() ; 12720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type of the value 12740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 12750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Find the type plane in the module map 12770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 12780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1279b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 12800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the type in the function map too 12810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 12820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 12830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 12840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 12850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 12860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 12870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1288b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module map 1289b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1290b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 1291b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert( MVI != MI->second.map.end() && "Value not found"); 1292b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1293b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 12940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 12960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1297b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1298b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1299b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1300b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + FVI->second; 13010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else there is not a corresponding type plane in the function map 13040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 13050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( MI != mMap.end() && "No such type plane!" ); 13060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Look up the value in the module's map 13070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 13080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If we didn't find it, it wasn't inserted. 13090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( MVI != MI->second.map.end() && "Value not found"); 13100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // We found it only in the module level and function level 13110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // didn't even have a type plane. 13120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 13130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1316b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // N.B. Can only get here if !TheFunction 13170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure the type plane exists 13190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( MI != mMap.end() && "No such type plane!" ); 13200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 13210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 13220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure we found it. 13230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( MVI != MI->second.map.end() && "Value not found" ); 13240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Return it. 13250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 13260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 13270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Create a new slot, or return the existing slot if it is already 13300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// inserted. Note that the logic here parallels getSlot but instead 13310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// of asserting when the Value* isn't found, it inserts the value. 13320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::createSlot(const Value *V) { 13330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't insert a null Value to SlotMachine"); 13340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( !isa<Type>(V) && "Can't insert a Type into SlotMachine"); 1335b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1336b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 13370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 13390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Just ignore void typed things 13410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (VTy == Type::VoidTy) return 0; // FIXME: Wrong return value! 13420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Look up the type plane for the Value's type from the module map 13440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 13450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1346b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 13470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type plane for the Value's type from the function map 13480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 13490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 13500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 13510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 13520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 13530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 13540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1355b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If there is no corresponding type plane in the module map 1356b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1357b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1358b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module map 1359b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1360b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 1361b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1362b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1363b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1364b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1365b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 13660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 13680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1369b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1370b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return FVI->second; 1371b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1372b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1373b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1374b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1375b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + FVI->second; 13760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else there is not a corresponding type plane in the function map 13790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 13800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the type plane doesn't exists at the module level 13810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI == mMap.end() ) { 1382b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 13830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else type plane exists at the module level, examine it 13840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1385b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module's map 1386b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1387b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it there either 1388b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1389b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1390b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index of the function map insertion. 1391b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + insertValue(V); 1392b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1393b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 13940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1398b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // N.B. Can only get here if !TheFunction 13990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the module map's type plane is not for the Value's type 14010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI != mMap.end() ) { 14020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 14030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 14040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MVI != MI->second.map.end() ) 14050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 14060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return insertValue(V); 14090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Low level insert function. Minimal checking is done. This 14130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function is just for the convenience of createSlot (above). 14140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::insertValue(const Value *V ) { 14150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert(V && "Can't insert a null Value into SlotMachine!"); 14160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert(!isa<Type>(V) && "Can't insert a Type into SlotMachine!"); 1417b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1418b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 14190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1420b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If this value does not contribute to a plane (is void) 14210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // or if the value already has a name then ignore it. 1422b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if (V->getType() == Type::VoidTy || V->hasName() ) { 14230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("ignored value " << *V << "\n"); 14240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return 0; // FIXME: Wrong return value 14250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type *VTy = V->getType(); 14280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned DestSlot = 0; 14290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1430b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 14310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = fMap.find( VTy ); 14320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( I == fMap.end() ) 14330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I = fMap.insert(std::make_pair(VTy,Plane())).first; 14340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 14350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 14360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = mMap.find( VTy ); 14370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( I == mMap.end() ) 14380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I = mMap.insert(std::make_pair(VTy,Plane())).first; 14390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 14400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1443b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer DestSlot << " ["); 14440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // G = Global, C = Constant, T = Type, F = Function, o = other 14450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG((isa<GlobalVariable>(V) ? "G" : (isa<Constant>(V) ? "C" : 14460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer (isa<Function>(V) ? "F" : "o")))); 14470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("]\n"); 14480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return DestSlot; 14490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14519231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// vim: sw=2 1452