AsmWriter.cpp revision 81dfeb3264d3c1f619c3f73046ded1ac6883e59d
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 1202b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// Note that these routines must be extremely tolerant of various errors in the 138f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner// LLVM code, because it can be used for debugging transformations. 1402b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 15009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 16009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 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" 21d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner#include "llvm/CallingConv.h" 22f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Constants.h" 233eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 24863517aea0b06770c809396be985c1c4cc50d3c4Chris Lattner#include "llvm/InlineAsm.h" 25b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 2644336292fcd9f3f99cbfc2c3366bea0cf95bb675Misha Brukman#include "llvm/Instructions.h" 27f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Module.h" 28007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 29551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/StringExtras.h" 30551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/STLExtras.h" 318f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling#include "llvm/Support/CFG.h" 32cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey#include "llvm/Support/MathExtras.h" 338f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling#include "llvm/Support/Streams.h" 34007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 3531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 36d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 370a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattnernamespace llvm { 380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 39edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer// Make virtual table appear in this compilation unit. 40edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid SpencerAssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 41edd5d9ece15f73ec1a31423a4ae39774aa6c521cReid Spencer 420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// This class provides computation of slot numbers for LLVM Assembly writing. 430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @brief LLVM Assembly Writing Slot Computation. 440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerclass SlotMachine { 450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Types 470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A mapping of Values to slot numbers 510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer typedef std::map<const Value*, unsigned> ValueMap; 520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer typedef std::map<const Type*, unsigned> TypeMap; 530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A plane with next slot number and ValueMap 55fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman struct ValuePlane { 560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned next_slot; ///< The next slot number to use 570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap map; ///< The map of Value* -> unsigned 580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 590e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer }; 600e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 610e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer struct TypePlane { 620e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned next_slot; 630e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap map; 640e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane() { next_slot = 0; } 650e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer void clear() { map.clear(); next_slot = 0; } 660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer }; 670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The map of planes by Type 690e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer typedef std::map<const Type*, ValuePlane> TypedPlanes; 700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Constructors 730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a module 760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Module *M ); 770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a function, starting out in incorp state. 790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Function *F ); 800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Accessors 830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Return the slot number of the specified value in it's type 860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// plane. Its an error to ask for something not in the SlotMachine. 870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Its an error to ask for a Type* 8869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int getSlot(const Value *V); 890e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer int getSlot(const Type*Ty); 90fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer 91fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer /// Determine if a Value has a slot or not 92fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer bool hasSlot(const Value* V); 930e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool hasSlot(const Type* Ty); 940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Mutators 970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 99fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// If you'd like to deal with a function instead of just a module, use 1000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// this method to get its data into the SlotMachine. 101fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman void incorporateFunction(const Function *F) { 102fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman TheFunction = F; 10328531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 10428531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer } 1050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 106fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// After calling incorporateFunction, use this method to remove the 107fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// most recently incorporated function from the SlotMachine. This 1080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// will reset the state of the machine back to just the module contents. 1090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void purgeFunction(); 1100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Implementation Details 1130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerprivate: 115b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// This function does the actual initialization. 116b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer inline void initialize(); 117b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 118fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// Values can be crammed into here at will. If they haven't 1190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// been inserted already, they get inserted, otherwise they are ignored. 1200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Either way, the slot number for the Value* is returned. 1210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned createSlot(const Value *V); 1220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned createSlot(const Type* Ty); 1230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Insert a value into the value table. Return the slot number 1250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// that it now occupies. BadThings(TM) will happen if you insert a 126fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman /// Value that's already been inserted. 1270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned insertValue( const Value *V ); 1280e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned insertValue( const Type* Ty); 1290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Add all of the module level global variables (and their initializers) 1310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// and function declarations, but not the contents of those functions. 1320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void processModule(); 1330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 134b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// Add all of the functions arguments, basic blocks, and instructions 135b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void processFunction(); 136b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 1380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void operator=(const SlotMachine &); // DO NOT IMPLEMENT 1390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Data 1420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 1440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The module for which we are holding slot numbers 146b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Module* TheModule; 1470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 148b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// @brief The function for which we are holding slot numbers 149b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Function* TheFunction; 15028531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer bool FunctionProcessed; 1510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the module level data 1530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes mMap; 1540e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane mTypes; 1550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the function level data 1570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes fMap; 1580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane fTypes; 1590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer}; 1630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1640a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner} // end namespace llvm 1650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1667f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintModulePass> 1673dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerX("printm", "Print module to stderr"); 1687f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattnerstatic RegisterPass<PrintFunctionPass> 1693dd965c954a49c12fc63888372ae6e35d56f6db9Chris LattnerY("print","Print function to stderr"); 170f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 171fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 1727b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 1737b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 1740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine); 1757a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 176fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Type *T, 1770e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool PrintName, 1780e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type *, std::string> &TypeTable, 1790e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine); 1800e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 181207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 182949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 183207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 184949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 186949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 18779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 188207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 189949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 190207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 191207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 192207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 193207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerstatic SlotMachine *createSlotMachine(const Value *V) { 195949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 1960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(FA->getParent()); 197949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 1980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(I->getParent()->getParent()); 199949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 2000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(BB->getParent()); 201949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 2020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(GV->getParent()); 203949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 2040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(Func); 205c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 206c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 207c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 208009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 20924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 21024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 21124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 2129913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenosstatic std::string getLLVMName(const std::string &Name, 2139913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos bool prefixName = true) { 21424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 21524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 21624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 21724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 21824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 21924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 22024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 22124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 22224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 22324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 22424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 22524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 22624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 22724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 228fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 22924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 2309913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos if (prefixName) 2319913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos return "%"+Name; 2329913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos else 2339913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos return Name; 23424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 23524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 236207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 237ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 238ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 239ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 240207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 2417b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 2426e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 2436e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 2449231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::type_const_iterator TI = ST.type_begin(); 2459231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; TI != ST.type_end(); ++TI ) { 2469231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // As a heuristic, don't insert pointer to primitive types, because 2479231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // they are used too often to have a single useful name. 2489231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 2499231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Type *Ty = cast<Type>(TI->second); 2509231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer if (!isa<PointerType>(Ty) || 251b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 252b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 2539231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 254207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 255207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 256207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 257207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 258207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 259fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void calcTypeName(const Type *Ty, 2604ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::vector<const Type *> &TypeStack, 2614ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::map<const Type *, std::string> &TypeNames, 2624ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string & Result){ 2634ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) { 2644ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += Ty->getDescription(); // Base case 2654ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2664ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 267207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 268207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2697b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 2704ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (I != TypeNames.end()) { 2714ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += I->second; 2724ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2734ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 274207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2754ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (isa<OpaqueType>(Ty)) { 2764ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 2774ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2784ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 27988c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 280207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 281207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 282207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 283207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 284fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // This is another base case for the recursion. In this case, we know 285207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 286207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 2874ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Slot < CurSize) { 2884ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 2894ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2904ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 291207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 292207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 293fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 294f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 2956bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 296949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 2974ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 2984ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += " ("; 299d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 300d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 301d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 302207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3034ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 304207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 3052761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 306d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 307207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 308207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 309207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 310207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 311207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 312207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 313949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 3144ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "{ "; 315d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 316d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 317d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 318207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3194ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 320207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 321207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 322207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 323207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 324207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 325fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman calcTypeName(cast<PointerType>(Ty)->getElementType(), 3264ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell TypeStack, TypeNames, Result); 3274ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "*"; 328207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 329207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 330949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 3314ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "[" + utostr(ATy->getNumElements()) + " x "; 3324ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 3334ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "]"; 334207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 335207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 336715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke case Type::PackedTyID: { 337715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke const PackedType *PTy = cast<PackedType>(Ty); 338715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += "<" + utostr(PTy->getNumElements()) + " x "; 339715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); 340715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Result += ">"; 341715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke break; 342715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 3439e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 3444ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 3459e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 346207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 3474ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "<unrecognized-type>"; 348207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 349207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 350207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 3514ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 352207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 353207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 354207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3559d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 3569d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 3579d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 3587b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 3597b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 360207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 361207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 362207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 363daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 364daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 365207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 366207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 3677b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 368207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 369207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 370207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 371207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 372207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 373207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 3747b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 3754ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string TypeName; 3764ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(Ty, TypeStack, TypeNames, TypeName); 377697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 3784ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return (Out << TypeName); 379207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 380207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 381e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 3829d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 3839d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 3849d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 3859d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 38631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 38731f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 388fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << ' '; 389207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 390207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 391207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 3926e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 3937b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 394207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 395fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 3967b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 397207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 3987b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 399207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 400207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 401207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 40218365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// PrintEscapedString - Print each character of the specified string, escaping 40318365506ebe3e28593cb36951f17f08e75712a29Chris Lattner// it if it is not printable or if it is an escape char. 40418365506ebe3e28593cb36951f17f08e75712a29Chris Lattnerstatic void PrintEscapedString(const std::string &Str, std::ostream &Out) { 40518365506ebe3e28593cb36951f17f08e75712a29Chris Lattner for (unsigned i = 0, e = Str.size(); i != e; ++i) { 40618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner unsigned char C = Str[i]; 40718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (isprint(C) && C != '"' && C != '\\') { 40818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << C; 40918365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } else { 41018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << '\\' 41118365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 41218365506ebe3e28593cb36951f17f08e75712a29Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 41318365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 41418365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 41518365506ebe3e28593cb36951f17f08e75712a29Chris Lattner} 41618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 41781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencerstatic const char * getPredicateText(unsigned predicate) { 41881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer const char * pred = "unknown"; 41981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer switch (predicate) { 42081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_FALSE: pred = "false"; break; 42181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 42281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGT: pred = "ogt"; break; 42381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OGE: pred = "oge"; break; 42481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLT: pred = "olt"; break; 42581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_OLE: pred = "ole"; break; 42681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ONE: pred = "one"; break; 42781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ORD: pred = "ord"; break; 42881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNO: pred = "uno"; break; 42981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 43081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGT: pred = "ugt"; break; 43181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UGE: pred = "uge"; break; 43281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULT: pred = "ult"; break; 43381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_ULE: pred = "ule"; break; 43481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_UNE: pred = "une"; break; 43581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case FCmpInst::FCMP_TRUE: pred = "true"; break; 43681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_EQ: pred = "eq"; break; 43781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_NE: pred = "ne"; break; 43881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGT: pred = "sgt"; break; 43981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SGE: pred = "sge"; break; 44081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLT: pred = "slt"; break; 44181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_SLE: pred = "sle"; break; 44281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGT: pred = "ugt"; break; 44381dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_UGE: pred = "uge"; break; 44481dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULT: pred = "ult"; break; 44581dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer case ICmpInst::ICMP_ULE: pred = "ule"; break; 44681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer } 44781dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer return pred; 44881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer} 44981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer 450fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// @brief Internal constant writer. 451fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 4527b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 4537b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 4540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 45538a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey const int IndentSize = 4; 45638a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey static std::string Indent = "\n"; 45766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 4589fb471df2ee4a35fd94ebf8156f76a83eacfffbbChris Lattner Out << (CB->getValue() ? "true" : "false"); 459b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 460b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer if (CI->getType()->isSigned()) 461b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Out << CI->getSExtValue(); 462b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer else 463b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer Out << CI->getZExtValue(); 46466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 46566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 46666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 46766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 46866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 46966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 47066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 47166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 47266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 47366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 47466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 47566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 47666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 47766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 478b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 47966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 48066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 48171d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner Out << StrVal; 48271d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner return; 48366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 484fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 48566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 48666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 48771d94d16b6011b4e9be69678addb9265a6c65266Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && 48866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 489cb6682fa44e13262bdef7dd22b4ba90f8c2e7b97Jim Laskey Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())); 49066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 491de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 492de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 49366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 49466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 49566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 496fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // 49766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 49818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner if (CA->isString()) { 49966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 50018365506ebe3e28593cb36951f17f08e75712a29Chris Lattner PrintEscapedString(CA->getAsString(), Out); 50166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 50266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 50366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 50440c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '['; 5057a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 50640c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 50766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 5087a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 5090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 5107a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 5117a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 51266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 5137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 5140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypeTable, Machine); 5157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 5187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 52040c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '{'; 521a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey unsigned N = CS->getNumOperands(); 522a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey if (N) { 52338a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) { 52438a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Indent += std::string(IndentSize, ' '); 52538a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << Indent; 52638a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } else { 52738a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey Out << ' '; 52838a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey } 5297a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 5307a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5317a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 5320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 5337a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 534a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey for (unsigned i = 1; i < N; i++) { 5357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 53638a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Out << Indent; 5377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 5387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5397a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 5400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 5417a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 54238a409c7ae3f6d1a29879fca26d9dcc032488386Jim Laskey if (N > 2) Indent.resize(Indent.size() - IndentSize); 5437a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 544a3f332bdc3e8fd1ac78dd3dc868d871e9086c5fdJim Laskey 5457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 546715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) { 547715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke const Type *ETy = CP->getType()->getElementType(); 548fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(CP->getNumOperands() > 0 && 549715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke "Number of operands for a PackedConst must be > 0"); 550715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << '<'; 551715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ' '; 552715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 553715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke WriteAsOperandInternal(Out, CP->getOperand(0), 554715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke PrintName, TypeTable, Machine); 555715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { 556715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << ", "; 557715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke printTypeInt(Out, ETy, TypeTable); 558715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke WriteAsOperandInternal(Out, CP->getOperand(i), PrintName, 559715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke TypeTable, Machine); 560715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke } 561715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke Out << " >"; 5627a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 5637a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 5647a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 565b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner } else if (isa<UndefValue>(CV)) { 566b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner Out << "undef"; 567b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner 568c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 56981dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << CE->getOpcodeName(); 57081dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer if (CE->isCompare()) 57181dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(CE->getPredicate()); 57281dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " ("; 573fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 574b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 575b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 5760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine); 577b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 578c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 579b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 580fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 5813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (CE->isCast()) { 58295586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 58395586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 58495586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 5853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 58640c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ')'; 58795586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 5887a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 589b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 5907a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 5927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 594ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 595ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 596ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 597ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 598fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 5997b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 6007b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 6010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 60240c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 6037970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if ((PrintName || isa<GlobalValue>(V)) && V->hasName()) 60424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 6057970396014eacbe719eb171448ddc546c1ad2289Reid Spencer else { 6067970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CV = dyn_cast<Constant>(V); 60780cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (CV && !isa<GlobalValue>(CV)) { 6080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteConstantInt(Out, CV, PrintName, TypeTable, Machine); 60980cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 61080cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "asm "; 61180cd11561892a639a2628d19815af0695b5dbcaaChris Lattner if (IA->hasSideEffects()) 61280cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "sideeffect "; 61380cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 61480cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getAsmString(), Out); 61580cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << "\", \""; 61680cd11561892a639a2628d19815af0695b5dbcaaChris Lattner PrintEscapedString(IA->getConstraintString(), Out); 61780cd11561892a639a2628d19815af0695b5dbcaaChris Lattner Out << '"'; 61880cd11561892a639a2628d19815af0695b5dbcaaChris Lattner } else { 6197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 6200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine) { 621b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer Slot = Machine->getSlot(V); 6227a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 6230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine = createSlotMachine(V); 6245b5cc5f2a1aa9741fe81052a6a2d5dcf1d5bd533Chris Lattner if (Machine) 62569566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = Machine->getSlot(V); 62669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 62769566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = -1; 628b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer delete Machine; 6297a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 63069566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 63169566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << '%' << Slot; 63269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 63369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << "<badref>"; 6347a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 6367a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 6377a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6389d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 6399d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 6409d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 6419d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 64231f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 643fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman bool PrintType, bool PrintName, 6449d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman const Module *Context) { 6457b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 646607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 6477a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 6486e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 649607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 650207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 6517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 6527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 653fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 654607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 655622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 656622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 657622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 658fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// WriteAsOperandInternal - Write the name of the specified value out to 659fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman/// the specified ostream. This can be useful when you just want to print 6600e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// int %reg126, not the whole instruction that generated it. 6610e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// 662fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanstatic void WriteAsOperandInternal(std::ostream &Out, const Type *T, 6630e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool PrintName, 6640e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type*, std::string> &TypeTable, 6650e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine) { 6660e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << ' '; 6670e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer int Slot; 6680e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (Machine) { 6690e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Slot = Machine->getSlot(T); 6700e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (Slot != -1) 6710e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << '%' << Slot; 6720e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer else 6730e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << "<badref>"; 6740e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 6750e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << T->getDescription(); 6760e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 6770e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 6780e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6790e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// WriteAsOperand - Write the name of the specified value out to the specified 6800e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// ostream. This can be useful when you just want to print int %reg126, not 6810e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// the whole instruction that generated it. 6820e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// 6830e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty, 684fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman bool PrintType, bool PrintName, 6850e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer const Module *Context) { 6860e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type *, std::string> TypeNames; 6870e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert(Context != 0 && "Can't write types as operand without module context"); 6880e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6890e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer fillTypeNameTable(Context, TypeNames); 6900e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6910e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // if (PrintType) 6920e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // printTypeInt(Out, V->getType(), TypeNames); 693fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 6940e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer printTypeInt(Out, Ty, TypeNames); 6950e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6960e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0); 6970e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return Out; 6980e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 6990e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 70031f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 701d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 702007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 7030313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman std::ostream &Out; 7040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine &Machine; 705c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 7067b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 70795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 708009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 7090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 71095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 7110313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 712c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 713c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 714c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 715c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 716207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 717009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 718009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 719c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 720c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 72179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 722c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 7237e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 724e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 725da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 726009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 72766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 72866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 7295cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 7305cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 731f771bea7402f05f59b2857586de9934ff1c7bbf5Misha Brukmanprivate: 732c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 733c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 734e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 735c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 73679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 73773e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 738c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 7397e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 7402761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7412761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 7422761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 7432761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 7447b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 7450313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return printTypeInt(Out, Ty, TypeNames); 7462761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7472761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7482761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 7492761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 7502761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 7517b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 752c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 753e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 754e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 7557e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 756009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 75773b7495a96e21e1515df86414e0636dbf1395fc5Reid Spencer} // end of llvm namespace 758009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 759ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 760ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 761ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 7627b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 7637e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 7642761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 765d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 766d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 767d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 7680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 7697a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 7702761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7712761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 7720313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FTy->getNumParams()) Out << ", "; 7730313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; 7742761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7750313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 7767e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 7770313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "{ "; 778d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 779d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 780d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 7810313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 7822761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 7832761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " }"; 7857e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 78640c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(PTy->getElementType()) << '*'; 7877e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 7880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '[' << ATy->getNumElements() << " x "; 78940c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(ATy->getElementType()) << ']'; 7905527c0b6d1bda2c63212f91837792663469fd764Reid Spencer } else if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) { 7915527c0b6d1bda2c63212f91837792663469fd764Reid Spencer Out << '<' << PTy->getNumElements() << " x "; 7925527c0b6d1bda2c63212f91837792663469fd764Reid Spencer printType(PTy->getElementType()) << '>'; 7935527c0b6d1bda2c63212f91837792663469fd764Reid Spencer } 7943ed469ccd7b028a030b550d84b7336d146f5d8faReid Spencer else if (isa<OpaqueType>(Ty)) { 7950313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "opaque"; 7962761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 797b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 7980313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<unknown derived type>"; 7992761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 8002761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 8010313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return Out; 8022761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 8032761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 8042761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 805fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanvoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 806b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer bool PrintName) { 807aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner if (Operand != 0) { 808aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner if (PrintType) { Out << ' '; printType(Operand->getType()); } 809aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine); 810aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner } else { 811aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner Out << "<null operand!>"; 812aab1820816facf83d7bda8f01e3d85ced99601f3Chris Lattner } 813007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 814007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 815007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 816c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 81731ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner if (!M->getModuleIdentifier().empty() && 818fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // Don't print the ID if it will start a new line (which would 81931ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner // require a comment char before it). 82031ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner M->getModuleIdentifier().find('\n') == std::string::npos) 82131ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 82231ab1b3d74440908889fc8ea0615c1d397478360Chris Lattner 823cf7ff2b4c8c18d67aced9d7ba84482819b38a84bOwen Anderson if (!M->getDataLayout().empty()) 824d2f9e609aa40de7049ebb6f838e7ba6579e3fb6aChris Lattner Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 825cf7ff2b4c8c18d67aced9d7ba84482819b38a84bOwen Anderson 826eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getEndianness()) { 8270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::LittleEndian: Out << "target endian = little\n"; break; 8280313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::BigEndian: Out << "target endian = big\n"; break; 829eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyEndianness: break; 830eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 831eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getPointerSize()) { 8320313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer32: Out << "target pointersize = 32\n"; break; 8330313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer64: Out << "target pointersize = 64\n"; break; 834eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyPointerSize: break; 835eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 836cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (!M->getTargetTriple().empty()) 837c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 838fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 839cc041ba03aed685400197fb938b7a583713d25afChris Lattner if (!M->getModuleInlineAsm().empty()) { 84042a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // Split the string into lines, to make it easier to read the .ll file. 841cc041ba03aed685400197fb938b7a583713d25afChris Lattner std::string Asm = M->getModuleInlineAsm(); 84242a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t CurPos = 0; 84342a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner size_t NewLine = Asm.find_first_of('\n', CurPos); 84442a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner while (NewLine != std::string::npos) { 84542a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // We found a newline, print the portion of the asm string from the 84642a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner // last newline up to this newline. 84742a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "module asm \""; 84842a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 84942a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out); 85042a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner Out << "\"\n"; 85142a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner CurPos = NewLine+1; 85242a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner NewLine = Asm.find_first_of('\n', CurPos); 85342a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner } 85471cdba31774ce18ed32e89f1c6f7716ab923aa46Chris Lattner Out << "module asm \""; 85542a162ed8023088e7a4a7d81325381bd8d437bb7Chris Lattner PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); 85618365506ebe3e28593cb36951f17f08e75712a29Chris Lattner Out << "\"\n"; 85718365506ebe3e28593cb36951f17f08e75712a29Chris Lattner } 85818365506ebe3e28593cb36951f17f08e75712a29Chris Lattner 85944da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the dependent libraries and emit them. 860cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LI = M->lib_begin(); 861cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Module::lib_iterator LE = M->lib_end(); 862cddc86f27c822af960fc8d344a86a63fce6eab76Reid Spencer if (LI != LE) { 863cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << "deplibs = [ "; 864cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner while (LI != LE) { 86544da7d79760998f9a70340b49a3811229838224dChris Lattner Out << '"' << *LI << '"'; 866c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer ++LI; 867cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner if (LI != LE) 868cfe97b78e787d232f4a82f5ff0afadf75ba95f6cChris Lattner Out << ", "; 869c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer } 870c9a1f0dcdde056a2cdbc446a9d6853684402263fReid Spencer Out << " ]\n"; 87183f6a77c8fc27eba21bca05be37663f3a6e123a1Reid Spencer } 872e59eaf407a675845e278c2769e3dbed9f1daae8cReid Spencer 87344da7d79760998f9a70340b49a3811229838224dChris Lattner // Loop over the symbol table, emitting all named constants. 8746e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 875fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 876e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) 8777e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 878007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8790313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\nimplementation ; Functions:\n"; 880fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 88144da7d79760998f9a70340b49a3811229838224dChris Lattner // Output all of the functions. 8827e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 8837e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 884009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 885009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 886c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 8870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; 888d70684f7585a85c4248c1c224059478108741c70Chris Lattner 889fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if (!GV->hasInitializer()) 890b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov switch (GV->getLinkage()) { 891b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 892b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 893b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov default: Out << "external "; break; 894b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } 8954ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 8964ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 897b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 898b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 899b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 900b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::AppendingLinkage: Out << "appending "; break; 901b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 902b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 903b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 904b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalLinkage: break; 9053c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman case GlobalValue::GhostLinkage: 9068f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling llvm_cerr << "GhostLinkage not allowed in AsmWriter!\n"; 9073c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman abort(); 9084ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 909d70684f7585a85c4248c1c224059478108741c70Chris Lattner 9100313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << (GV->isConstant() ? "constant " : "global "); 9117a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 912d70684f7585a85c4248c1c224059478108741c70Chris Lattner 9137970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (GV->hasInitializer()) { 9147970396014eacbe719eb171448ddc546c1ad2289Reid Spencer Constant* C = cast<Constant>(GV->getInitializer()); 9157970396014eacbe719eb171448ddc546c1ad2289Reid Spencer assert(C && "GlobalVar initializer isn't constant?"); 916acc928042daf6912267544a623bdaba3633fec36Reid Spencer writeOperand(GV->getInitializer(), false, isa<GlobalValue>(C)); 9177970396014eacbe719eb171448ddc546c1ad2289Reid Spencer } 91830caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner 91960962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->hasSection()) 92060962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << ", section \"" << GV->getSection() << '"'; 92160962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (GV->getAlignment()) 92230caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << ", align " << GV->getAlignment(); 92360962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner 9247e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 9250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 92670cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 92770cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 928009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9299231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// printSymbolTable - Run through symbol table looking for constants 9309231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// and types. Emit their declarations. 931c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 9329231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 9339231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the types. 9349231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::type_const_iterator TI = ST.type_begin(); 9359231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TI != ST.type_end(); ++TI ) { 9360313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(TI->first) << " = type "; 9379231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 9389231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Make sure we print out at least one level of the type structure, so 9399231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // that we do not get %FILE = type %FILE 9409231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 9419231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer printTypeAtLeastOneLevel(TI->second) << "\n"; 9429231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer } 943fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 9449231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the constants, in type plane order. 9459231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 9469231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer PI != ST.plane_end(); ++PI ) { 9479231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 9489231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 9499231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 9509231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; VI != VE; ++VI) { 9517970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Value* V = VI->second; 9527970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CPV = dyn_cast<Constant>(V) ; 9537970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (CPV && !isa<GlobalValue>(V)) { 954b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer printConstant(CPV); 955007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 956007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 957739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 958009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 959009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 960009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 961ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printConstant - Print out a constant pool entry... 962ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 963e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 964007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 965007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 966009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9671333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 9680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(CPV->getName()) << " ="; 969009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 970009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 9717a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 972009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9737e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 9740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 975009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 976009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 977ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 978ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 9797e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 980009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 9810313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 9824ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 983333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner // Ensure that no local symbols conflict with global symbols. 984333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner const_cast<Function*>(F)->renameLocalSymbols(); 985333529e6be764aa1e4f83eb25817407a758f37c8Chris Lattner 9860313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 98795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 9884ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 989b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov switch (F->getLinkage()) { 990b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "declare dllimport "; break; 991b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "declare extern_weak "; break; 992b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov default: Out << "declare "; 993b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } 9944ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 9954ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 996b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::InternalLinkage: Out << "internal "; break; 997b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 998b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::WeakLinkage: Out << "weak "; break; 999b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::AppendingLinkage: Out << "appending "; break; 1000b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 1001b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 1002b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 10034ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 10043c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman case GlobalValue::GhostLinkage: 10058f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling llvm_cerr << "GhostLinkage not allowed in AsmWriter!\n"; 10063c8f2c66e585f946569fa62cbf26509009d2df93Misha Brukman abort(); 10074ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 10084ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 1009d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention. 1010d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (F->getCallingConv()) { 1011d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 1012f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::CSRet: Out << "csretcc "; break; 1013f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Fast: Out << "fastcc "; break; 1014f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::Cold: Out << "coldcc "; break; 1015f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1016f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1017d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << "cc" << F->getCallingConv() << " "; break; 1018d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1019d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 102040c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(F->getReturnType()) << ' '; 10214d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 10220313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(F->getName()); 10234d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 10240313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\"\""; 10250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 10260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.incorporateFunction(F); 1027007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1028c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 10297e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 1030007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1031e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) 103269da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 1033007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 1034007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 10357e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 10360313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FT->getNumParams()) Out << ", "; 10370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; // Output varargs portion of signature! 1038007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 10390313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 1040007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 104160962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner if (F->hasSection()) 104260962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner Out << " section \"" << F->getSection() << '"'; 104330caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner if (F->getAlignment()) 104430caa2876cd500b49e27b6810ab5dec96398c6faChris Lattner Out << " align " << F->getAlignment(); 104560962dbfbaa4a9c3ca6fced08fb90b748aa99203Chris Lattner 10467e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 10470313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 104803e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 10490313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " {"; 1050fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1051b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 10527e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 10537e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 1054007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 10550313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "}\n"; 1056007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 1057007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 10580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.purgeFunction(); 1059009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1060009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1061ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 1062ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 1063ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 106473e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 1065009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 106639220ded940aa408d5dce9b8ab33e87e1d7a23d7Chris Lattner if (Arg != Arg->getParent()->arg_begin()) Out << ", "; 1067009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1068009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 1069c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 1070fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1071009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 1072009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 10730313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' ' << getLLVMName(Arg->getName()); 1074009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1075009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1076ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 1077ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 1078c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1079009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 10809913e596782bf9c0f1f31bf397ccc0ddfa967debAlkis Evlogimenos Out << "\n" << getLLVMName(BB->getName(), false) << ':'; 1081afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 10820313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n; <label>:"; 108369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int Slot = Machine.getSlot(BB); 108469566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 10850313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << Slot; 108669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 10870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<badref>"; 1088061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 10894e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 10904e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 10910313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; Error: Block without parent!"; 10924e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner else { 10934e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB != &BB->getParent()->front()) { // Not the entry block? 10944e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner // Output predecessors for the block... 10950313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t;"; 10964e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 1097fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 10984e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (PI == PE) { 10990313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " No predecessors!"; 11004e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } else { 11010313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " preds ="; 110240efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner writeOperand(*PI, false, true); 11034e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner for (++PI; PI != PE; ++PI) { 11040313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 11054e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner writeOperand(*PI, false, true); 11064e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } 110740efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 1108061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 1109009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1110fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 11110313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1112009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11130313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 111495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 1115007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 11167e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 11177e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 11189f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 11190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1120009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1121009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1122e02fa8551d20081534afa46e0976811687e5183aChris Lattner 1123ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 1124ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 1125ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 11267e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 11277e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 11280313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; <"; 112940c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(V.getType()) << '>'; 1130e02fa8551d20081534afa46e0976811687e5183aChris Lattner 11317e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 113269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int SlotNum = Machine.getSlot(&V); 113369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (SlotNum == -1) 11340313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ":<badref>"; 1135fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer else 11360313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ':' << SlotNum; // Print out the def slot taken. 1137e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 11385c461404fed8d1def8eae02e6574bc5b16502575Chris Lattner Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses 1139e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1140e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 1141e02fa8551d20081534afa46e0976811687e5183aChris Lattner 11423a9ec2463ddeba0820f284e2952bd6919cd5e080Reid Spencer// This member is called for each Instruction in a function.. 11437e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 11440313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 114595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 11460313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t"; 1147009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1148009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 11497e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 11500313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(I.getName()) << " = "; 1151009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1152ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a volatile load or store, print out the volatile marker. 1153e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1154ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) { 11550313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "volatile "; 1156ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) { 1157ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner // If this is a call, check if it's a tail call. 1158ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner Out << "tail "; 1159ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner } 1160e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 1161009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 11620313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << I.getOpcodeName(); 1163009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 116474f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer // Print out the compare instruction predicates 116574f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) { 116681dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(FCI->getPredicate()); 116774f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) { 116881dfeb3264d3c1f619c3f73046ded1ac6883e59dReid Spencer Out << " " << getPredicateText(ICI->getPredicate()); 116974f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer } 117074f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer 1171009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 11727e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1173009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1174009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 11757e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 11767e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 11770313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 1178009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 11790313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 11807e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 1181009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 118294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 1183009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 11840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(Operand , true); Out << ','; 11850313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(1), true); Out << " ["; 1186009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11877e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 11880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t\t"; 11890313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), true); Out << ','; 11907e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 1191009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 11920313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t]"; 1193b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 11940313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 11957e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 11960313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1197009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11987e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 11990313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (op) Out << ", "; 1200fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman Out << '['; 12010313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), false); Out << ','; 12020313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op+1), false); Out << " ]"; 1203c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 1204e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 12050313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " void"; 1206d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1207d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1208d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (CI->getCallingConv()) { 1209d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 12100deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::CSRet: Out << " csretcc"; break; 12110deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 12120deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1213f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1214f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1215d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << CI->getCallingConv(); break; 1216d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1217d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 12187a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 12197a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 12207a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 1221268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 12227a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 1223b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 12247a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 1225268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 12267a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1227fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 1228c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 12290313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 1230268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 1231268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 1232268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 1233268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 12340313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 1235d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner if (CI->getNumOperands() > 1) writeOperand(CI->getOperand(1), true); 12367e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 12370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 12387e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 1239009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1240009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 12410313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )"; 12427e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 12437a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 12447a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 12457a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 12467a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 1247d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner // Print the calling convention being used. 1248d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner switch (II->getCallingConv()) { 1249d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner case CallingConv::C: break; // default 12500deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::CSRet: Out << " csretcc"; break; 12510deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Fast: Out << " fastcc"; break; 12520deaab89feb963b314428e3c3c565343cc30b5c9Chris Lattner case CallingConv::Cold: Out << " coldcc"; break; 1253f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1254f824868ed9d2cc756a797f6dbd67732f75e31cd6Anton Korobeynikov case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1255d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner default: Out << " cc" << II->getCallingConv(); break; 1256d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner } 1257d511898b581826694e6c651e23343b1e1ba5ba64Chris Lattner 12587a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 12597a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 12607a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 12617a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 12627a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 1263fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman (!isa<PointerType>(RetTy) || 12647a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 12650313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 12667a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 12677a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 12687a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 12697a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 12707a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 12710313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 12727e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 12737e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 12740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 12757e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 1276e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1277e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12780313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )\n\t\t\tto"; 1279e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 12800313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " unwind"; 1281aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 1282e02fa8551d20081534afa46e0976811687e5183aChris Lattner 12837e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 12840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 128594dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 128694dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 12870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 128894dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 1289009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 129014b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman if (AI->getAlignment()) { 12919fad0b9974beb76bef763b8fed71d0c8644403d4Chris Lattner Out << ", align " << AI->getAlignment(); 129214b0529532904b9e5a1e34526b4a3209f3e5bc62Nate Begeman } 1293e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 129441495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 12950313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " to "; 12967e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 12974d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 129841495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 12990313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 13008f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 1301009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 1302009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1303fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // PrintAllTypes - Instructions who have operands of all the same type 1304009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 1305009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 1306009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 1307009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 1308009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1309cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // Shift Left & Right print both types even for Ubyte LHS, and select prints 1310cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // types even if all operands are bools. 131100f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I) || 131200f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner isa<ShuffleVectorInst>(I)) { 1313ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 1314ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 1315ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1316ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 1317ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 1318ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 1319ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 1320ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 1321009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1322009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1323fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1324c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 13250313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1326ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 1327c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 1328009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 13297e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 13300313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (i) Out << ','; 13317e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 1332009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1333009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1334009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1335e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 13360313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1337009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1338009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1339009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1340009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1341009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 1342009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1343009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 134495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(this); 134695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 134775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1348009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1349009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 135075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 13510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 135295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 135375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1354b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 1355b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 135695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 135895e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 1359009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 136075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1361009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1362009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1363cc041ba03aed685400197fb938b7a583713d25afChris Lattnervoid InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 136480cd11561892a639a2628d19815af0695b5dbcaaChris Lattner WriteAsOperand(o, this, true, true, 0); 1365cc041ba03aed685400197fb938b7a583713d25afChris Lattner} 1366cc041ba03aed685400197fb938b7a583713d25afChris Lattner 136795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 13680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 1369fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman AssemblyWriter W(o, SlotTable, 137095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 137175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 137275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1373009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 137495e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 137575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 13760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(F); 137795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1378009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 137975cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 138075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1381009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 138275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 138375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 13843bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 138540c732cc52a5c71cead461646667ef5b13801923Misha Brukman o << ' ' << getType()->getDescription() << ' '; 1386a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng 1387a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng std::map<const Type *, std::string> TypeTable; 1388a4ffcc23a268cf9b74a74035a92c9a3c4a753214Evan Cheng WriteConstantInt(o, this, false, TypeTable, 0); 1389009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1390009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1391fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukmanvoid Type::print(std::ostream &o) const { 139275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 139375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 139475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 139575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1396009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1397009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 139873e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 1399144d9baf5e5665ab1b0e815402d92ee615034b01Chris Lattner WriteAsOperand(o, this, true, true, 1400144d9baf5e5665ab1b0e815402d92ee615034b01Chris Lattner getParent() ? getParent()->getParent() : 0); 140175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1402009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1403fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Value::dump - allow easy printing of Values from the debugger. 1404fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 14058f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendlingvoid Value::dump() const { print(std::cerr); llvm_cerr << '\n'; } 1406fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer 1407fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Type::dump - allow easy printing of Values from the debugger. 1408fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 14098f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendlingvoid Type::dump() const { print(std::cerr); llvm_cerr << '\n'; } 1410009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 141175cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 141275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 141375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 1414da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1415da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 1416da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 1417da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 14180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC = new SlotMachine(M ); 141940c732cc52a5c71cead461646667ef5b13801923Misha Brukman AW = new AssemblyWriter(Out, *SC, M, 0); 1420da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 1421da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 1422da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1423da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1424da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1425da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 1426da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 1427da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 1428da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1429da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 14300a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris LattnerCachedWriter &CachedWriter::operator<<(const Value &V) { 1431da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 14320a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner if (const Instruction *I = dyn_cast<Instruction>(&V)) 1433fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(I); 14340a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(&V)) 1435fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(BB); 14360a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const Function *F = dyn_cast<Function>(&V)) 1437fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(F); 14380a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V)) 1439fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(GV); 1440fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman else 14410a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner AW->writeOperand(&V, true, true); 1442da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 1443da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 14445cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 14450a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris LattnerCachedWriter& CachedWriter::operator<<(const Type &Ty) { 14465cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (SymbolicTypes) { 14475cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module *M = AW->getModule(); 14480a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner if (M) WriteTypeSymbolic(Out, &Ty, M); 14490e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 14500a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner AW->write(&Ty); 14510e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 14520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return *this; 14535cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman} 1454e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman 14550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 14560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===-- SlotMachine Implementation 14570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 14580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#if 0 14608f487662869d10c866b9ebdccb8f6a7509d3ab56Bill Wendling#define SC_DEBUG(X) llvm_cerr << X 14610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#else 14620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) 14630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#endif 14640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Module level constructor. Causes the contents of the Module (sans functions) 14660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// to be added to the slot table. 1467fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanSlotMachine::SlotMachine(const Module *M) 1468b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule(M) ///< Saved for lazy initialization. 1469b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(0) 147028531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 14710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 14720e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , mTypes() 14730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 14740e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , fTypes() 14750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 14760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 14770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Function level constructor. Causes the contents of the Module and the one 14790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function provided to be added to the slot table. 1480fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha BrukmanSlotMachine::SlotMachine(const Function *F ) 1481b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization 1482b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(F) ///< Saved for lazy initialization 148328531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer , FunctionProcessed(false) 14840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 14850e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , mTypes() 14860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 14870e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , fTypes() 14880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 1489b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer} 1490b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1491b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencerinline void SlotMachine::initialize(void) { 1492fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if ( TheModule) { 1493fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processModule(); 1494b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheModule = 0; ///< Prevent re-processing next time we're called. 1495b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer } 1496fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if ( TheFunction && ! FunctionProcessed) { 1497fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman processFunction(); 14980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Iterate through all the global variables, functions, and global 1502fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// variable initializers and create slots for them. 15030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::processModule() { 15040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processModule!\n"); 15050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the global variables to the value table... 1507e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end(); 15080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 15090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 15100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the functions to the table 15120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 15130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 15140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 15150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processModule!\n"); 15170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1520b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// Process the arguments, basic blocks, and instructions of a function. 1521b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencervoid SlotMachine::processFunction() { 15220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processFunction!\n"); 15230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the function arguments 1525fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 1526e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner AE = TheFunction->arg_end(); AI != AE; ++AI) 15270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(AI); 15280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("Inserting Instructions:\n"); 15300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the basic blocks and instructions 1532fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman for (Function::const_iterator BB = TheFunction->begin(), 1533b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer E = TheFunction->end(); BB != E; ++BB) { 15340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(BB); 15350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 15360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 15370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 154028531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = true; 154128531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer 15420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processFunction!\n"); 15430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Clean up after incorporating a function. This is the only way 1546b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// to get out of the function incorporation state that affects the 1547b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// getSlot/createSlot lock. Function incorporation state is indicated 1548b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// by TheFunction != 0. 15490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::purgeFunction() { 15500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin purgeFunction!\n"); 15510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer fMap.clear(); // Simply discard the function level map 15520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer fTypes.clear(); 1553b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheFunction = 0; 155428531c71cd142f623d56a7ea13df2e014eebff54Reid Spencer FunctionProcessed = false; 15550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end purgeFunction!\n"); 15560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Get the slot number for a value. This function will assert if you 15590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// ask for a Value that hasn't previously been inserted with createSlot. 15600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Types are forbidden because Type does not inherit from Value (any more). 156169566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattnerint SlotMachine::getSlot(const Value *V) { 15620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't get slot for null Value" ); 1563fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1564fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman "Can't insert a non-GlobalValue Constant into SlotMachine"); 1565b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1566b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Check for uninitialized state and do lazy initialization 1567b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer this->initialize(); 15680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type of the value 15700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 15710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Find the type plane in the module map 15730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 15740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1575b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 15760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the type in the function map too 15770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 15780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 15790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 15800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 15810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 15820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 15830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1584e9e326e2eb223ea4bc6762a099ce3c314e4daedbChris Lattner // Look up the value in the module map. 1585e9e326e2eb223ea4bc6762a099ce3c314e4daedbChris Lattner if (MI == mMap.end()) return -1; 1586b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1587b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 158869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MVI == MI->second.map.end()) return -1; 1589b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert( MVI != MI->second.map.end() && "Value not found"); 1590b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1591fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman return MVI->second; 15920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 15940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1595b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1596b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1597b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1598d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner if (MI != mMap.end()) 1599d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner return MI->second.next_slot + FVI->second; 1600d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner else 1601d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner return FVI->second; 16020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 16030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 16040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 16050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1606fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer // N.B. Can get here only if either !TheFunction or the function doesn't 1607fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer // have a corresponding type plane for the Value 16080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure the type plane exists 161069566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MI == mMap.end()) return -1; 16110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 16120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 16130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure we found it. 161469566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MVI == MI->second.map.end()) return -1; 16150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Return it. 16160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 16170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 16180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16190e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// Get the slot number for a value. This function will assert if you 16200e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// ask for a Value that hasn't previously been inserted with createSlot. 16210e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// Types are forbidden because Type does not inherit from Value (any more). 16220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerint SlotMachine::getSlot(const Type *Ty) { 16230e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert( Ty && "Can't get slot for null Type" ); 16240e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16250e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Check for uninitialized state and do lazy initialization 16260e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer this->initialize(); 16270e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16280e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 16290e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the Type in the function map 16300e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator FTI = fTypes.map.find(Ty); 16310e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If the Type doesn't exist in the function map 16320e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( FTI == fTypes.map.end() ) { 16330e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 16340e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If we didn't find it, it wasn't inserted 1635fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if (MTI == mTypes.map.end()) 16360e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return -1; 16370e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // We found it only at the module level 1638fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman return MTI->second; 16390e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16400e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // else the value exists in the function map 16410e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 16420e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return the slot number as the module's contribution to 16430e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // the type plane plus the index in the function's contribution 16440e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // to the type plane. 16450e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return mTypes.next_slot + FTI->second; 16460e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 16470e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 16480e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16490e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // N.B. Can get here only if either !TheFunction 16500e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16510e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the value in the module's map 16520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 16530e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Make sure we found it. 16540e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (MTI == mTypes.map.end()) return -1; 16550e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return it. 16560e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 16570e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 16580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Create a new slot, or return the existing slot if it is already 16600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// inserted. Note that the logic here parallels getSlot but instead 16610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// of asserting when the Value* isn't found, it inserts the value. 16620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::createSlot(const Value *V) { 16630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't insert a null Value to SlotMachine"); 1664fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1665fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman "Can't insert a non-GlobalValue Constant into SlotMachine"); 16660d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 16680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Just ignore void typed things 16700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (VTy == Type::VoidTy) return 0; // FIXME: Wrong return value! 16710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Look up the type plane for the Value's type from the module map 16730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 16740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1675b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 16760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type plane for the Value's type from the function map 16770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 16780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 16790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 16800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 16810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 16820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 16830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1684b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If there is no corresponding type plane in the module map 1685b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1686b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1687b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module map 1688b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1689b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 1690b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1691b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1692b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1693b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1694b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 16950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 16960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 16970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1698b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1699b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return FVI->second; 1700b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1701b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1702b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1703b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1704b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + FVI->second; 17050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else there is not a corresponding type plane in the function map 17080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 17090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the type plane doesn't exists at the module level 17100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI == mMap.end() ) { 1711b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 17120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else type plane exists at the module level, examine it 17130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1714b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module's map 1715b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1716b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it there either 1717b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1718b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1719b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index of the function map insertion. 1720b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + insertValue(V); 1721b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1722b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 17230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1727b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // N.B. Can only get here if !TheFunction 17280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the module map's type plane is not for the Value's type 17300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI != mMap.end() ) { 17310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 17320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1733fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if ( MVI != MI->second.map.end() ) 17340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 17350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return insertValue(V); 17380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 17390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17400e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// Create a new slot, or return the existing slot if it is already 17410e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// inserted. Note that the logic here parallels getSlot but instead 17420e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// of asserting when the Value* isn't found, it inserts the value. 17430e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerunsigned SlotMachine::createSlot(const Type *Ty) { 17440e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert( Ty && "Can't insert a null Type to SlotMachine"); 17450e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 17460e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 17470e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the Type in the function map 17480e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator FTI = fTypes.map.find(Ty); 17490e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If the type doesn't exist in the function map 17500e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( FTI == fTypes.map.end() ) { 17510e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Look up the type in the module map 17520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 17530e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If we didn't find it, it wasn't inserted 17540e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( MTI == mTypes.map.end() ) 17550e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return insertValue(Ty); 17560e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer else 17570e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // We found it only at the module level 17580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 17590e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 17600e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // else the value exists in the function map 17610e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 17620e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return the slot number as the module's contribution to 17630e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // the type plane plus the index in the function's contribution 17640e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // to the type plane. 17650e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return mTypes.next_slot + FTI->second; 17660e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 17670e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 17680e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 17690e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // N.B. Can only get here if !TheFunction 17700e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 17710e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the type in the module's map 17720e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 1773fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if ( MTI != mTypes.map.end() ) 17740e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 17750e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 17760e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return insertValue(Ty); 17770e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 17780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Low level insert function. Minimal checking is done. This 17800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function is just for the convenience of createSlot (above). 17810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::insertValue(const Value *V ) { 17820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert(V && "Can't insert a null Value into SlotMachine!"); 1783fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1784fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman "Can't insert a non-GlobalValue Constant into SlotMachine"); 17850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1786b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If this value does not contribute to a plane (is void) 1787fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman // or if the value already has a name then ignore it. 1788b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if (V->getType() == Type::VoidTy || V->hasName() ) { 17890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("ignored value " << *V << "\n"); 17900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return 0; // FIXME: Wrong return value 17910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 17920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 17930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type *VTy = V->getType(); 17940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned DestSlot = 0; 17950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1796b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 17970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = fMap.find( VTy ); 1798fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman if ( I == fMap.end() ) 17990e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer I = fMap.insert(std::make_pair(VTy,ValuePlane())).first; 18000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 18010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 18020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = mMap.find( VTy ); 18030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( I == mMap.end() ) 18040e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer I = mMap.insert(std::make_pair(VTy,ValuePlane())).first; 18050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 18060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 18070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1808fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1809b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer DestSlot << " ["); 18100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // G = Global, C = Constant, T = Type, F = Function, o = other 1811fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : 18127970396014eacbe719eb171448ddc546c1ad2289Reid Spencer (isa<Constant>(V) ? 'C' : 'o')))); 18130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("]\n"); 18140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return DestSlot; 18150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 18160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 18170e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// Low level insert function. Minimal checking is done. This 18180e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// function is just for the convenience of createSlot (above). 18190e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerunsigned SlotMachine::insertValue(const Type *Ty ) { 18200e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert(Ty && "Can't insert a null Type into SlotMachine!"); 18210e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 18220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned DestSlot = 0; 18230e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 18240e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 18250e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer DestSlot = fTypes.map[Ty] = fTypes.next_slot++; 18260e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 18270e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer DestSlot = fTypes.map[Ty] = fTypes.next_slot++; 18280e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 18290e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SC_DEBUG(" Inserting type [" << DestSlot << "] = " << Ty << "\n"); 18300e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return DestSlot; 18310e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 18320e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 18339231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// vim: sw=2 1834