AsmWriter.cpp revision acc928042daf6912267544a623bdaba3633fec36
18da78afce3609f8ac31bef9d1310744a47bbd0ccChris Lattner//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// This library implements the functionality defined in llvm/Assembly/Writer.h 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 1202b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// Note that these routines must be extremely tolerant of various errors in the 138f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner// LLVM code, because it can be used for debugging transformations. 1402b9399baef2afc1a0c8c83152d2f28145658bbcChris Lattner// 15009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 16009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 17da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner#include "llvm/Assembly/CachedWriter.h" 1875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner#include "llvm/Assembly/Writer.h" 19f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner#include "llvm/Assembly/PrintModulePass.h" 2095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner#include "llvm/Assembly/AsmAnnotationWriter.h" 21f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Constants.h" 223eb59c0074978cb4687779365dbe664e2e18e0b2Chris Lattner#include "llvm/DerivedTypes.h" 23b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve#include "llvm/Instruction.h" 24009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include "llvm/iMemory.h" 25e02fa8551d20081534afa46e0976811687e5183aChris Lattner#include "llvm/iTerminators.h" 267061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iPHINode.h" 277061dc50b2513731d7b346ab16183cda4a44619fChris Lattner#include "llvm/iOther.h" 28f2d577b27a56a928fa3e77ab0cd83e7597751313Chris Lattner#include "llvm/Module.h" 29007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include "llvm/SymbolTable.h" 305cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman#include "llvm/Assembly/Writer.h" 31061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner#include "llvm/Support/CFG.h" 32cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/StringExtras.h" 33cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/STLExtras.h" 34007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner#include <algorithm> 3531f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 36d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 370a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattnernamespace llvm { 380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// This class provides computation of slot numbers for LLVM Assembly writing. 400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @brief LLVM Assembly Writing Slot Computation. 410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerclass SlotMachine { 420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Types 440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A mapping of Values to slot numbers 480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer typedef std::map<const Value*, unsigned> ValueMap; 490e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer typedef std::map<const Type*, unsigned> TypeMap; 500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief A plane with next slot number and ValueMap 520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer struct ValuePlane { 530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned next_slot; ///< The next slot number to use 540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap map; ///< The map of Value* -> unsigned 550e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 560e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer }; 570e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 580e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer struct TypePlane { 590e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned next_slot; 600e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap map; 610e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane() { next_slot = 0; } 620e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer void clear() { map.clear(); next_slot = 0; } 630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer }; 640d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The map of planes by Type 660e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer typedef std::map<const Type*, ValuePlane> TypedPlanes; 670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Constructors 700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a module 730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Module *M ); 740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief Construct from a function, starting out in incorp state. 760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const Function *F ); 770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Accessors 800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Return the slot number of the specified value in it's type 830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// plane. Its an error to ask for something not in the SlotMachine. 840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Its an error to ask for a Type* 8569566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int getSlot(const Value *V); 860e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer int getSlot(const Type*Ty); 87fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer 88fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer /// Determine if a Value has a slot or not 89fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer bool hasSlot(const Value* V); 900e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool hasSlot(const Type* Ty); 910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Mutators 940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// If you'd like to deal with a function instead of just a module, use 970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// this method to get its data into the SlotMachine. 98b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void incorporateFunction(const Function *F) { TheFunction = F; } 990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// After calling incorporateFunction, use this method to remove the 1010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// most recently incorporated function from the SlotMachine. This 1020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// will reset the state of the machine back to just the module contents. 1030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void purgeFunction(); 1040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Implementation Details 1070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerprivate: 109b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// This function does the actual initialization. 110b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer inline void initialize(); 111b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Values can be crammed into here at will. If they haven't 1130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// been inserted already, they get inserted, otherwise they are ignored. 1140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Either way, the slot number for the Value* is returned. 1150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned createSlot(const Value *V); 1160e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned createSlot(const Type* Ty); 1170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Insert a value into the value table. Return the slot number 1190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// that it now occupies. BadThings(TM) will happen if you insert a 1200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Value that's already been inserted. 1210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned insertValue( const Value *V ); 1220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned insertValue( const Type* Ty); 1230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// Add all of the module level global variables (and their initializers) 1250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// and function declarations, but not the contents of those functions. 1260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void processModule(); 1270d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 128b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// Add all of the functions arguments, basic blocks, and instructions 129b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer void processFunction(); 130b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1310d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT 1320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer void operator=(const SlotMachine &); // DO NOT IMPLEMENT 1330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @name Data 1360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @{ 1370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerpublic: 1380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The module for which we are holding slot numbers 140b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Module* TheModule; 1410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 142b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer /// @brief The function for which we are holding slot numbers 143b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer const Function* TheFunction; 1440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the module level data 1460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes mMap; 1470e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane mTypes; 1480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer /// @brief The TypePlanes map for the function level data 1500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes fMap; 1510e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypePlane fTypes; 1520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// @} 1540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer}; 1560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1570a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner} // end namespace llvm 1580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 159a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintModulePass> 160a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerX("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 161a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris Lattnerstatic RegisterPass<PrintFunctionPass> 162a6275ccdf5e1aa208afde56c498e2b13e16442f0Chris LattnerY("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 163f082b80828c13dcb7fb29ad5167ed161c1031534Chris Lattner 1647b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 1657b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 1667b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 1670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine); 1687a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 1690e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerstatic void WriteAsOperandInternal(std::ostream &Out, const Type *T, 1700e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool PrintName, 1710e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type *, std::string> &TypeTable, 1720e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine); 1730e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 174207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic const Module *getModuleFromVal(const Value *V) { 175949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *MA = dyn_cast<Argument>(V)) 176207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return MA->getParent() ? MA->getParent()->getParent() : 0; 177949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 178207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return BB->getParent() ? BB->getParent()->getParent() : 0; 179949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner else if (const Instruction *I = dyn_cast<Instruction>(V)) { 18079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 181207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return M ? M->getParent() : 0; 182949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 183207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return GV->getParent(); 184207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner return 0; 185207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 186207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 1870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerstatic SlotMachine *createSlotMachine(const Value *V) { 188949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner if (const Argument *FA = dyn_cast<Argument>(V)) { 1890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(FA->getParent()); 190949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 1910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(I->getParent()->getParent()); 192949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 1930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(BB->getParent()); 194949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 1950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(GV->getParent()); 196949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner } else if (const Function *Func = dyn_cast<Function>(V)) { 1970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return new SlotMachine(Func); 198c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 199c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner return 0; 200c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner} 201009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 20224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// getLLVMName - Turn the specified string into an 'LLVM name', which is either 20324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// prefixed with % (if the string only contains simple characters) or is 20424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner// surrounded with ""'s (if it has special chars in it). 20524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattnerstatic std::string getLLVMName(const std::string &Name) { 20624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(!Name.empty() && "Cannot get empty name!"); 20724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 20824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // First character cannot start with a number... 20924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if (Name[0] >= '0' && Name[0] <= '9') 21024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 21124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 21224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // Scan to see if we have any characters that are not on the "white list" 21324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner for (unsigned i = 0, e = Name.size(); i != e; ++i) { 21424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner char C = Name[i]; 21524b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner assert(C != '"' && "Illegal character in LLVM value name!"); 21624b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && 21724b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner C != '-' && C != '.' && C != '_') 21824b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "\"" + Name + "\""; 21924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner } 22024b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 22124b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner // If we get here, then the identifier is legal to use as a "VarID". 22224b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner return "%"+Name; 22324b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner} 22424b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner 225207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 226ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// fillTypeNameTable - If the module has a symbol table, take all global types 227ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// and stuff their names into the TypeNames map. 228ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 229207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattnerstatic void fillTypeNameTable(const Module *M, 2307b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 2316e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (!M) return; 2326e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable &ST = M->getSymbolTable(); 2339231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::type_const_iterator TI = ST.type_begin(); 2349231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; TI != ST.type_end(); ++TI ) { 2359231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // As a heuristic, don't insert pointer to primitive types, because 2369231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // they are used too often to have a single useful name. 2379231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 2389231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer const Type *Ty = cast<Type>(TI->second); 2399231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer if (!isa<PointerType>(Ty) || 240b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 241b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 2429231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 243207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 244207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 245207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 246207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 247207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2484ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswellstatic void calcTypeName(const Type *Ty, 2494ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::vector<const Type *> &TypeStack, 2504ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::map<const Type *, std::string> &TypeNames, 2514ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string & Result){ 2524ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) { 2534ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += Ty->getDescription(); // Base case 2544ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2554ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 256207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 257207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 2587b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 2594ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (I != TypeNames.end()) { 2604ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += I->second; 2614ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2624ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 263207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 2644ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (isa<OpaqueType>(Ty)) { 2654ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 2664ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2674ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 26888c17380646dbb7c0c5054a392de5a46d17620baChris Lattner 269207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the Type is already on the stack... 270207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner unsigned Slot = 0, CurSize = TypeStack.size(); 271207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 272207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 273207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // This is another base case for the recursion. In this case, we know 274207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // that we have looped back to a type that we have previously visited. 275207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Generate the appropriate upreference to handle this. 2764ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell if (Slot < CurSize) { 2774ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 2784ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 2794ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell } 280207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 281207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 282207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 283f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 2846bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner case Type::FunctionTyID: { 285949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const FunctionType *FTy = cast<FunctionType>(Ty); 2864ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 2874ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += " ("; 288d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 289d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 290d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 291207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 2924ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 293207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 2942761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 295d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (FTy->getNumParams()) Result += ", "; 296207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += "..."; 297207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 298207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ")"; 299207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 300207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 301207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::StructTyID: { 302949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const StructType *STy = cast<StructType>(Ty); 3034ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "{ "; 304d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 305d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 306d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 307207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += ", "; 3084ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(*I, TypeStack, TypeNames, Result); 309207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 310207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner Result += " }"; 311207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 312207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 313207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::PointerTyID: 3144ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(cast<PointerType>(Ty)->getElementType(), 3154ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell TypeStack, TypeNames, Result); 3164ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "*"; 317207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 318207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner case Type::ArrayTyID: { 319949a3628024248db01d5b13e03c415e0c88e90e4Chris Lattner const ArrayType *ATy = cast<ArrayType>(Ty); 3204ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "[" + utostr(ATy->getNumElements()) + " x "; 3214ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 3224ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "]"; 323207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner break; 324207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 3259e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner case Type::OpaqueTyID: 3264ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "opaque"; 3279e094c40df10d928a1242f8652dc56ebd41d38fdChris Lattner break; 328207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner default: 3294ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell Result += "<unrecognized-type>"; 330207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 331207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 332207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner TypeStack.pop_back(); // Remove self from stack... 3334ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return; 334207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 335207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 336207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3379d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// printTypeInt - The internal guts of printing out a type that has a 3389d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// potentially named portion. 3399d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 3407b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 3417b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeNames) { 342207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Primitive types always print out their description, regardless of whether 343207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // they have been named or not. 344207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 345daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 346daf2a492a7eef1d4f68b1ed04b401ca6140c191fChris Lattner return Out << Ty->getDescription(); 347207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 348207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Check to see if the type is named. 3497b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 350207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner if (I != TypeNames.end()) return Out << I->second; 351207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 352207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Otherwise we have a type that has not been named but is a derived type. 353207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // Carefully recurse the type hierarchy to print out any contained symbolic 354207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // names. 355207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // 3567b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::vector<const Type *> TypeStack; 3574ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell std::string TypeName; 3584ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell calcTypeName(Ty, TypeStack, TypeNames, TypeName); 359697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 3604ff620a867b7fcd13fb641c4ea872bd9be4b7b71John Criswell return (Out << TypeName); 361207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 362207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 363e51e03b3c649ed9419bd0e920c03ef9023ccee48Chris Lattner 3649d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 3659d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type, iff there is an entry in the modules symbol table for the specified 3669d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// type or one of it's component types. This is slower than a simple x << Type 3679d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 36831f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 36931f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattner const Module *M) { 37040c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 371207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 372207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // If they want us to print out a type, attempt to make it symbolic if there 373207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner // is a symbol table in the module... 3746e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (M) { 3757b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 376207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 377207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3787b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return printTypeInt(Out, Ty, TypeNames); 379207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } else { 3807b8660d72f35f5ddea0c81eb71f2bdd60fd62832Chris Lattner return Out << Ty->getDescription(); 381207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner } 382207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner} 383207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 3847970396014eacbe719eb171448ddc546c1ad2289Reid Spencer/// @brief Internal constant writer. 3857b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteConstantInt(std::ostream &Out, const Constant *CV, 3867b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 3877b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> &TypeTable, 3880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 38966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 39066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << (CB == ConstantBool::True ? "true" : "false"); 39166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 39266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 39366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 39466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << CI->getValue(); 39566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 39666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // We would like to output the FP constant value in exponential notation, 39766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // but we cannot do this if doing so will lose precision. Check here to 39866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // make sure that we only output it in exponential format if we can parse 39966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the value back and get the same value. 40066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 40166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner std::string StrVal = ftostr(CFP->getValue()); 40266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 40366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Check to make sure that the stringized number is not some string like 40466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 40566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // the string matches the "[-+]?[0-9]" regex. 40666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 40766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 40866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner ((StrVal[0] == '-' || StrVal[0] == '+') && 409b471a23a8506b7476890ee34a25ffbd1b553f3ffBrian Gaeke (StrVal[1] >= '0' && StrVal[1] <= '9'))) 41066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Reparse stringized version! 41166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (atof(StrVal.c_str()) == CFP->getValue()) { 41266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << StrVal; return; 41366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 41466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 41566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Otherwise we could not reparse it to exactly the same value, so we must 41666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // output the string in hexadecimal format! 41766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 41866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // Behave nicely in the face of C TBAA rules... see: 41966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // http://www.nullstone.com/htmls/category/aliastyp.htm 42066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 42166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner double Val = CFP->getValue(); 42266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner char *Ptr = (char*)&Val; 42366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 42466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner "assuming that double is 64 bits!"); 42566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "0x" << utohexstr(*(uint64_t*)Ptr); 42666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 427de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner } else if (isa<ConstantAggregateZero>(CV)) { 428de512b5b2edebe9c9021a92c7c7a9ae9fbc380d6Chris Lattner Out << "zeroinitializer"; 42966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 43066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // As a special case, print the array as a string if it is an array of 43166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // ubytes or an array of sbytes with positive values. 43266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner // 43366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner const Type *ETy = CA->getType()->getElementType(); 43466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 43566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 43666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (ETy == Type::SByteTy) 43766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) 43866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 43966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner isString = false; 44066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner break; 44166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 44266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 44366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner if (isString) { 44466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "c\""; 44566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 44654e3e8fd37a2e28868b5faf11e4b0af243c5a364Chris Lattner unsigned char C = 44754e3e8fd37a2e28868b5faf11e4b0af243c5a364Chris Lattner (unsigned char)cast<ConstantInt>(CA->getOperand(i))->getRawValue(); 44866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 449fc94446777fcdff03fdc09539bab25200936b43eChris Lattner if (isprint(C) && C != '"' && C != '\\') { 45066e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << C; 45166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { 45266e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << '\\' 45366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 45466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 45566e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 45666e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } 45766e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner Out << "\""; 45866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 45966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner } else { // Cannot output in string format... 46040c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '['; 4617a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CA->getNumOperands()) { 46240c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 46366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4647a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(0), 4650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4667a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 4677a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 46866e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner printTypeInt(Out, ETy, TypeTable); 4697a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 4700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypeTable, Machine); 4717a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4727a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4737a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " ]"; 4747a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4757a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 47640c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << '{'; 4777a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (CS->getNumOperands()) { 47840c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 4797a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 4807a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4817a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(0), 4820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4837a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4847a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner for (unsigned i = 1; i < CS->getNumOperands(); i++) { 4857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << ", "; 4867a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 4877a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4887a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner WriteAsOperandInternal(Out, CS->getOperand(i), 4890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer PrintName, TypeTable, Machine); 4907a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4917a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 4927a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 4937a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << " }"; 4947a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else if (isa<ConstantPointerNull>(CV)) { 4957a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner Out << "null"; 4967a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 497c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 49838d877365030f90b099d53ab6a66bd62271e330fChris Lattner Out << CE->getOpcodeName() << " ("; 499b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 500b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 501b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve printTypeInt(Out, (*OI)->getType(), TypeTable); 5020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine); 503b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (OI+1 != CE->op_end()) 504c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner Out << ", "; 505b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve } 506b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve 5071c93e5bd26cf1b41ed7bdf5561b8f20607488b0fChris Lattner if (CE->getOpcode() == Instruction::Cast) { 50895586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner Out << " to "; 50995586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner printTypeInt(Out, CE->getType(), TypeTable); 51095586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner } 51140c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ')'; 51295586b8c833aeca112907e69f545a6ea6e2103ffChris Lattner 5137a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 514b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve Out << "<placeholder or erroneous Constant>"; 5157a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5167a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 5177a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5187a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 519ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 520ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 521ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the whole instruction that generated it. 522ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 5237b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstatic void WriteAsOperandInternal(std::ostream &Out, const Value *V, 5247b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner bool PrintName, 5257b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type*, std::string> &TypeTable, 5260d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine *Machine) { 52740c732cc52a5c71cead461646667ef5b13801923Misha Brukman Out << ' '; 5287970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if ((PrintName || isa<GlobalValue>(V)) && V->hasName()) 52924b8a5d6e7c67b0fdfe98a5b6c3791b313dc904bChris Lattner Out << getLLVMName(V->getName()); 5307970396014eacbe719eb171448ddc546c1ad2289Reid Spencer else { 5317970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CV = dyn_cast<Constant>(V); 5327970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (CV && !isa<GlobalValue>(CV)) 5330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer WriteConstantInt(Out, CV, PrintName, TypeTable, Machine); 5347970396014eacbe719eb171448ddc546c1ad2289Reid Spencer else { 5357a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner int Slot; 5360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (Machine) { 537b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer Slot = Machine->getSlot(V); 5387a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } else { 5390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine = createSlotMachine(V); 54069566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Machine == 0) 54169566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = Machine->getSlot(V); 54269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 54369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Slot = -1; 544b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer delete Machine; 5457a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 54669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 54769566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << '%' << Slot; 54869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 54969566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner Out << "<badref>"; 5507a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5517a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner } 5527a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner} 5537a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5549d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// WriteAsOperand - Write the name of the specified value out to the specified 5559d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// ostream. This can be useful when you just want to print int %reg126, not 5569d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// the whole instruction that generated it. 5579d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman/// 55831f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 5599d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman bool PrintType, bool PrintName, 5609d0802e7dd165dd9b7372f12799f248e7f133287Misha Brukman const Module *Context) { 5617b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 562607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner if (Context == 0) Context = getModuleFromVal(V); 5637a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 5646e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner if (Context) 565607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner fillTypeNameTable(Context, TypeNames); 566207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner 5677a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner if (PrintType) 5687a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printTypeInt(Out, V->getType(), TypeNames); 5697a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner 570607dc6880ecfd4807de2163d37f2fa8877b7f62dChris Lattner WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 571622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner return Out; 572622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner} 573622f740a7dcf0b3520244e58b2233898fd4a46e4Chris Lattner 5740e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// WriteAsOperandInternal - Write the name of the specified value out to 5750e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// the specified ostream. This can be useful when you just want to print 5760e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// int %reg126, not the whole instruction that generated it. 5770e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// 5780e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerstatic void WriteAsOperandInternal(std::ostream &Out, const Type *T, 5790e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool PrintName, 5800e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type*, std::string> &TypeTable, 5810e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SlotMachine *Machine) { 5820e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << ' '; 5830e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer int Slot; 5840e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (Machine) { 5850e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Slot = Machine->getSlot(T); 5860e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (Slot != -1) 5870e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << '%' << Slot; 5880e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer else 5890e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << "<badref>"; 5900e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 5910e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer Out << T->getDescription(); 5920e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 5930e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 5940e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 5950e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// WriteAsOperand - Write the name of the specified value out to the specified 5960e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// ostream. This can be useful when you just want to print int %reg126, not 5970e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// the whole instruction that generated it. 5980e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// 5990e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerstd::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty, 6000e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer bool PrintType, bool PrintName, 6010e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer const Module *Context) { 6020e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer std::map<const Type *, std::string> TypeNames; 6030e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert(Context != 0 && "Can't write types as operand without module context"); 6040e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6050e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer fillTypeNameTable(Context, TypeNames); 6060e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6070e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // if (PrintType) 6080e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // printTypeInt(Out, V->getType(), TypeNames); 6090e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6100e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer printTypeInt(Out, Ty, TypeNames); 6110e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 6120e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0); 6130e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return Out; 6140e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 6150e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 61631f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnernamespace llvm { 617d8c2e42aeff8bdb3ac905b4721b3d3ca1f904cfaChris Lattner 618007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnerclass AssemblyWriter { 6190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman std::ostream &Out; 6200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine &Machine; 621c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner const Module *TheModule; 6227b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeNames; 62395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AnnotationWriter; 624009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerpublic: 6250d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 62695e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyAnnotationWriter *AAW) 6270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 628c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 629c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // If the module has a symbol table, take all global types and stuff their 630c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // names into the TypeNames map. 631c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // 632207b5bc6a15e12a87c3c861da680b8b23559a34cChris Lattner fillTypeNameTable(M, TypeNames); 633009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 634009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 635c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const Module *M) { printModule(M); } 636c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const GlobalVariable *G) { printGlobal(G); } 63779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner inline void write(const Function *F) { printFunction(F); } 638c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 6397e70829632f82de15db187845666aaca6e04b792Chris Lattner inline void write(const Instruction *I) { printInstruction(*I); } 640e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner inline void write(const Constant *CPV) { printConstant(CPV); } 641da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner inline void write(const Type *Ty) { printType(Ty); } 642009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 64366e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 64466e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 6455cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module* getModule() { return TheModule; } 6465cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 647009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattnerprivate : 648c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printModule(const Module *M); 649c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printSymbolTable(const SymbolTable &ST); 650e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner void printConstant(const Constant *CPV); 651c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printGlobal(const GlobalVariable *GV); 65279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner void printFunction(const Function *F); 65373e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner void printArgument(const Argument *FA); 654c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner void printBasicBlock(const BasicBlock *BB); 6557e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInstruction(const Instruction &I); 6562761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6572761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printType - Go to extreme measures to attempt to print out a short, 6582761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // symbolic version of a type name. 6592761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6607b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printType(const Type *Ty) { 6610313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return printTypeInt(Out, Ty, TypeNames); 6622761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 6632761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 6642761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 6652761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // without considering any symbolic types that we may have equal to it. 6662761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner // 6677b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 668c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner 669e02fa8551d20081534afa46e0976811687e5183aChris Lattner // printInfoComment - Print a little comment after the instruction indicating 670e02fa8551d20081534afa46e0976811687e5183aChris Lattner // which slot it occupies. 6717e70829632f82de15db187845666aaca6e04b792Chris Lattner void printInfoComment(const Value &V); 672009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner}; 67373b7495a96e21e1515df86414e0636dbf1395fc5Reid Spencer} // end of llvm namespace 674009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 675ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 676ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// without considering any symbolic types that we may have equal to it. 677ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 6787b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattnerstd::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 6797e70829632f82de15db187845666aaca6e04b792Chris Lattner if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 6802761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(FTy->getReturnType()) << " ("; 681d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner for (FunctionType::param_iterator I = FTy->param_begin(), 682d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner E = FTy->param_end(); I != E; ++I) { 683d5d89967206e1153d24abdb7b22002f7533f55c7Chris Lattner if (I != FTy->param_begin()) 6840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 6857a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner printType(*I); 6862761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 6872761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner if (FTy->isVarArg()) { 6880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FTy->getNumParams()) Out << ", "; 6890313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; 6902761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 6910313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 6927e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 6930313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "{ "; 694d21cd809b656d3011ec089536857e048e037159cChris Lattner for (StructType::element_iterator I = STy->element_begin(), 695d21cd809b656d3011ec089536857e048e037159cChris Lattner E = STy->element_end(); I != E; ++I) { 696d21cd809b656d3011ec089536857e048e037159cChris Lattner if (I != STy->element_begin()) 6970313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 6982761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(*I); 6992761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7000313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " }"; 7017e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 70240c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(PTy->getElementType()) << '*'; 7037e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 7040313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '[' << ATy->getNumElements() << " x "; 70540c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(ATy->getElementType()) << ']'; 7067e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 7070313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "opaque"; 7082761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } else { 709b4dbb4445c67fc46e56765035c2787028a66a614Vikram S. Adve if (!Ty->isPrimitiveType()) 7100313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<unknown derived type>"; 7112761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner printType(Ty); 7122761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner } 7130313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman return Out; 7142761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner} 7152761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 7162761e9f076bbe6c961629aece62db4b836a41ef8Chris Lattner 717007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattnervoid AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 718b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer bool PrintName) { 7190313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (PrintType) { Out << ' '; printType(Operand->getType()); } 7200313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine); 721007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner} 722007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 723007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 724c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printModule(const Module *M) { 725eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getEndianness()) { 7260313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::LittleEndian: Out << "target endian = little\n"; break; 7270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::BigEndian: Out << "target endian = big\n"; break; 728eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyEndianness: break; 729eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 730eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner switch (M->getPointerSize()) { 7310313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer32: Out << "target pointersize = 32\n"; break; 7320313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case Module::Pointer64: Out << "target pointersize = 64\n"; break; 733eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner case Module::AnyPointerSize: break; 734eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner } 735eb5d3a1526b2604feb07fe874907e30c8d2fcd6dChris Lattner 736007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Loop over the symbol table, emitting all named constants... 7376e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner printSymbolTable(M->getSymbolTable()); 73870cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 7397e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 7407e70829632f82de15db187845666aaca6e04b792Chris Lattner printGlobal(I); 741007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 7420313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\nimplementation ; Functions:\n"; 7435efa3ccbd17e81358f87474e53492871b1c83e41Vikram S. Adve 744b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of the functions... 7457e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 7467e70829632f82de15db187845666aaca6e04b792Chris Lattner printFunction(I); 747009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 748009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 749c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printGlobal(const GlobalVariable *GV) { 7500313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; 751d70684f7585a85c4248c1c224059478108741c70Chris Lattner 7524ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!GV->hasInitializer()) 7530313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "external "; 7544ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 7554ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (GV->getLinkage()) { 7560313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::InternalLinkage: Out << "internal "; break; 7570313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 7580313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::WeakLinkage: Out << "weak "; break; 7590313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::AppendingLinkage: Out << "appending "; break; 7604ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 7614ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 762d70684f7585a85c4248c1c224059478108741c70Chris Lattner 7630313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << (GV->isConstant() ? "constant " : "global "); 7647a1767520611d9ff6face702068de858e1cadf2cChris Lattner printType(GV->getType()->getElementType()); 765d70684f7585a85c4248c1c224059478108741c70Chris Lattner 7667970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (GV->hasInitializer()) { 7677970396014eacbe719eb171448ddc546c1ad2289Reid Spencer Constant* C = cast<Constant>(GV->getInitializer()); 7687970396014eacbe719eb171448ddc546c1ad2289Reid Spencer assert(C && "GlobalVar initializer isn't constant?"); 769acc928042daf6912267544a623bdaba3633fec36Reid Spencer writeOperand(GV->getInitializer(), false, isa<GlobalValue>(C)); 7707970396014eacbe719eb171448ddc546c1ad2289Reid Spencer } 771d70684f7585a85c4248c1c224059478108741c70Chris Lattner 7727e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*GV); 7730313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 77470cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner} 77570cc3397f84c2e1fd69c059a0ef89e398e847b00Chris Lattner 776009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 7779231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// printSymbolTable - Run through symbol table looking for constants 7789231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// and types. Emit their declarations. 779c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 7809231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7819231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the types. 7829231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::type_const_iterator TI = ST.type_begin(); 7839231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer TI != ST.type_end(); ++TI ) { 7840313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(TI->first) << " = type "; 7859231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7869231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Make sure we print out at least one level of the type structure, so 7879231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // that we do not get %FILE = type %FILE 7889231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // 7899231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer printTypeAtLeastOneLevel(TI->second) << "\n"; 7909231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer } 791007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 7929231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer // Print the constants, in type plane order. 7939231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 7949231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer PI != ST.plane_end(); ++PI ) { 7959231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 7969231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 7979231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer 7989231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer for (; VI != VE; ++VI) { 7997970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Value* V = VI->second; 8007970396014eacbe719eb171448ddc546c1ad2289Reid Spencer const Constant *CPV = dyn_cast<Constant>(V) ; 8017970396014eacbe719eb171448ddc546c1ad2289Reid Spencer if (CPV && !isa<GlobalValue>(V)) { 802b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer printConstant(CPV); 803007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 804007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 805739a56d26ddd76f7d073745d8be25c53cf39dce5Chris Lattner } 806009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 807009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 808009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 809ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printConstant - Print out a constant pool entry... 810ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 811e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattnervoid AssemblyWriter::printConstant(const Constant *CPV) { 812007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Don't print out unnamed constants, they will be inlined 813007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner if (!CPV->hasName()) return; 814009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8151333ed5b4fd3d30ba9ef56741af4d345a9e43953Chris Lattner // Print out name... 8160313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t" << getLLVMName(CPV->getName()) << " ="; 817009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 818009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Write the value out now... 8197a716addedc4938fa0ec6b77e5eeaced6eafc5d0Chris Lattner writeOperand(CPV, true, false); 820009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8217e70829632f82de15db187845666aaca6e04b792Chris Lattner printInfoComment(*CPV); 8220313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 823009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 824009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 825ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printFunction - Print all aspects of a function. 826ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 8277e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printFunction(const Function *F) { 828009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the return type and name... 8290313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 8304ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 8310313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 83295e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 8334ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (F->isExternal()) 8340313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "declare "; 8354ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner else 8364ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner switch (F->getLinkage()) { 8370313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::InternalLinkage: Out << "internal "; break; 8380313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 8390313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::WeakLinkage: Out << "weak "; break; 8400313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman case GlobalValue::AppendingLinkage: Out << "appending "; break; 8414ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner case GlobalValue::ExternalLinkage: break; 8424ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 8434ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 84440c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(F->getReturnType()) << ' '; 8454d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner if (!F->getName().empty()) 8460313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(F->getName()); 8474d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner else 8480313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\"\""; 8490313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 8500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.incorporateFunction(F); 851007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 852c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner // Loop over the arguments, printing them... 8537e70829632f82de15db187845666aaca6e04b792Chris Lattner const FunctionType *FT = F->getFunctionType(); 854007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 85569da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 85669da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner printArgument(I); 857007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 858007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Finish printing arguments... 8597e70829632f82de15db187845666aaca6e04b792Chris Lattner if (FT->isVarArg()) { 8600313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (FT->getNumParams()) Out << ", "; 8610313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "..."; // Output varargs portion of signature! 862007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 8630313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ')'; 864007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8657e70829632f82de15db187845666aaca6e04b792Chris Lattner if (F->isExternal()) { 8660313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 86703e2acb37f675b62c66a8cc78965e8b2623972ecChris Lattner } else { 8680313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " {"; 869007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 870b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // Output all of its basic blocks... for the function 8717e70829632f82de15db187845666aaca6e04b792Chris Lattner for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 8727e70829632f82de15db187845666aaca6e04b792Chris Lattner printBasicBlock(I); 873007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "}\n"; 875007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner } 876007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner 8770d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer Machine.purgeFunction(); 878009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 879009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 880ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printArgument - This member is called for every argument that is passed into 881ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// the function. Simply print it out 882ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 88373e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid AssemblyWriter::printArgument(const Argument *Arg) { 884009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Insert commas as we go... the first arg doesn't get a comma 8850313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (Arg != &Arg->getParent()->afront()) Out << ", "; 886009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 887009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output type... 888c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner printType(Arg->getType()); 889009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 890009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Output name, if available... 891009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (Arg->hasName()) 8920313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' ' << getLLVMName(Arg->getName()); 893009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 894009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 895ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printBasicBlock - This member is called for each basic block in a method. 896ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 897c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattnervoid AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 898009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner if (BB->hasName()) { // Print out the label if it exists... 8990313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n" << BB->getName() << ':'; 900afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner } else if (!BB->use_empty()) { // Don't print block # of no uses... 9010313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n; <label>:"; 90269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int Slot = Machine.getSlot(BB); 90369566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (Slot != -1) 9040313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << Slot; 90569566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner else 9060313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "<badref>"; 907061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 9084e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 9094e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB->getParent() == 0) 9100313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; Error: Block without parent!"; 9114e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner else { 9124e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (BB != &BB->getParent()->front()) { // Not the entry block? 9134e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner // Output predecessors for the block... 9140313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t;"; 9154e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 9164e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner 9174e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner if (PI == PE) { 9180313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " No predecessors!"; 9194e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } else { 9200313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " preds ="; 92140efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner writeOperand(*PI, false, true); 9224e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner for (++PI; PI != PE; ++PI) { 9230313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 9244e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner writeOperand(*PI, false, true); 9254e4d8624c5c44578d64fe1344670520cceec03f2Chris Lattner } 92640efcec8e879b3470b3c0ad9d8124abce2cd8915Chris Lattner } 927061269be9723f842931f18ad207acf9a66e0cf76Chris Lattner } 928009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 929afc38686b426645ad10562c7eddfd6785663f1bbChris Lattner 9300313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 931009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9320313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 93395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 934007377f381e253cc559db8d3c94fa89b0eb55fadChris Lattner // Output all of the instructions in the basic block... 9357e70829632f82de15db187845666aaca6e04b792Chris Lattner for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 9367e70829632f82de15db187845666aaca6e04b792Chris Lattner printInstruction(*I); 9379f717ef279f4b82e28c341c98a9aa602f01f9b27Chris Lattner 9380313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 939009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 940009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 941e02fa8551d20081534afa46e0976811687e5183aChris Lattner 942ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// printInfoComment - Print a little comment after the instruction indicating 943ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// which slot it occupies. 944ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 9457e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInfoComment(const Value &V) { 9467e70829632f82de15db187845666aaca6e04b792Chris Lattner if (V.getType() != Type::VoidTy) { 9470313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t\t; <"; 94840c732cc52a5c71cead461646667ef5b13801923Misha Brukman printType(V.getType()) << '>'; 949e02fa8551d20081534afa46e0976811687e5183aChris Lattner 9507e70829632f82de15db187845666aaca6e04b792Chris Lattner if (!V.hasName()) { 95169566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner int SlotNum = Machine.getSlot(&V); 95269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (SlotNum == -1) 9530313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ":<badref>"; 954fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer else 9550313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ':' << SlotNum; // Print out the def slot taken. 956e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 9570313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " [#uses=" << V.use_size() << ']'; // Output # uses 958e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 959e02fa8551d20081534afa46e0976811687e5183aChris Lattner} 960e02fa8551d20081534afa46e0976811687e5183aChris Lattner 961fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer/// printInstruction - This member is called for each Instruction in a function.. 962ab5c6003d23c19d23bbff1054900d208c55e0188Misha Brukman/// 9637e70829632f82de15db187845666aaca6e04b792Chris Lattnervoid AssemblyWriter::printInstruction(const Instruction &I) { 9640313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 96595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner 9660313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\t"; 967009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 968009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out name if it exists... 9697e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.hasName()) 9700313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << getLLVMName(I.getName()) << " = "; 971009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 972e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner // If this is a volatile load or store, print out the volatile marker 973e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 974e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) 9750313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "volatile "; 976e5e475e09d1e8a9ea1bda58b536867ff16600399Chris Lattner 977009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the opcode... 9780313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << I.getOpcodeName(); 979009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 980009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Print out the type of the operands... 9817e70829632f82de15db187845666aaca6e04b792Chris Lattner const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 982009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 983009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case conditional branches to swizzle the condition out to the front 9847e70829632f82de15db187845666aaca6e04b792Chris Lattner if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 9857e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(2), true); 9860313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 987009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner writeOperand(Operand, true); 9880313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 9897e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(1), true); 990009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 99194dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner } else if (isa<SwitchInst>(I)) { 992009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // Special case switch statement to get formatting nice and correct... 9930313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(Operand , true); Out << ','; 9940313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(1), true); Out << " ["; 995009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9967e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 9970313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t\t"; 9980313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), true); Out << ','; 9997e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op+1), true); 1000009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 10010313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n\t]"; 1002b00c582b6d40e6b9ff2d1ed4f5eaf7930e792aceChris Lattner } else if (isa<PHINode>(I)) { 10030313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 10047e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 10050313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1006009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 10077e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 10080313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (op) Out << ", "; 10090313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '['; 10100313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op ), false); Out << ','; 10110313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman writeOperand(I.getOperand(op+1), false); Out << " ]"; 1012c24d2088dc3d79e3b7e38a358b4a71f156c06836Chris Lattner } 1013e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<ReturnInst>(I) && !Operand) { 10140313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " void"; 1015e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CallInst>(I)) { 10167a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 10177a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 10187a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 1019268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner 10207a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the call instruction. We can 1021b579400cd72f274607f4964a9649ea4d38e04c46Chris Lattner // only do this if the first argument is a pointer to a nonvararg function, 10227a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 1023268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner // 10247a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 102594dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner (!isa<PointerType>(RetTy) || 1026c1b2718acf9d566c26188f2968dece0bf3f187e3Chris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 10270313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 1028268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, false); 1029268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } else { 1030268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner writeOperand(Operand, true); 1031268de0464ee9f0938bfa145fdd5e7f1a46b21cf7Chris Lattner } 10320313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 10337e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 10347e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 10350313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 10367e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 1037009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1038009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 10390313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )"; 10407e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 10417a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const PointerType *PTy = cast<PointerType>(Operand->getType()); 10427a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 10437a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner const Type *RetTy = FTy->getReturnType(); 10447a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 10457a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // If possible, print out the short form of the invoke instruction. We can 10467a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // only do this if the first argument is a pointer to a nonvararg function, 10477a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // and if the return type is not a pointer to a function. 10487a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner // 10497a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner if (!FTy->isVarArg() && 10507a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner (!isa<PointerType>(RetTy) || 10517a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 10520313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; printType(RetTy); 10537a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, false); 10547a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } else { 10557a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner writeOperand(Operand, true); 10567a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner } 10577a012299ced5cff02cec47055a63d3b2a78bb36fChris Lattner 10580313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << '('; 10597e70829632f82de15db187845666aaca6e04b792Chris Lattner if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 10607e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 10610313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 10627e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(op), true); 1063e02fa8551d20081534afa46e0976811687e5183aChris Lattner } 1064e02fa8551d20081534afa46e0976811687e5183aChris Lattner 10650313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " )\n\t\t\tto"; 1066e02fa8551d20081534afa46e0976811687e5183aChris Lattner writeOperand(II->getNormalDest(), true); 10670313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " unwind"; 1068aeb2a1d70807aa626f335fb23d47bc604ffeaa15Chris Lattner writeOperand(II->getUnwindDest(), true); 1069e02fa8551d20081534afa46e0976811687e5183aChris Lattner 10707e70829632f82de15db187845666aaca6e04b792Chris Lattner } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 10710313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 107294dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner printType(AI->getType()->getElementType()); 107394dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner if (AI->isArrayAllocation()) { 10740313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ','; 107594dc1f29cd1dc669680b7d3caa1f59862a656b83Chris Lattner writeOperand(AI->getArraySize(), true); 1076009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1077e02fa8551d20081534afa46e0976811687e5183aChris Lattner } else if (isa<CastInst>(I)) { 107841495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 10790313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << " to "; 10807e70829632f82de15db187845666aaca6e04b792Chris Lattner printType(I.getType()); 10814d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (isa<VAArgInst>(I)) { 108241495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 10830313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 10848f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner printType(I.getType()); 10854d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) { 108641495a21f9e881a2bea017caad9eed731f8f37e8Chris Lattner if (Operand) writeOperand(Operand, true); // Work with broken code 10870313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ", "; 10884d45bd007d0c3a3a6e5b3876b67fd495acb0db2bChris Lattner printType(VAN->getArgType()); 1089009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } else if (Operand) { // Print the normal way... 1090009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1091009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // PrintAllTypes - Instructions who have operands of all the same type 1092009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // omit the type from all but the first operand. If the instruction has 1093009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner // different type operands (for example br), then they are all printed. 1094009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner bool PrintAllTypes = false; 1095009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner const Type *TheType = Operand->getType(); 1096009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1097cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // Shift Left & Right print both types even for Ubyte LHS, and select prints 1098cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner // types even if all operands are bools. 1099cfdd148972c049291ee6f24f3201a573d9ac5809Chris Lattner if (isa<ShiftInst>(I) || isa<SelectInst>(I)) { 1100ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; 1101ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } else { 1102ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1103ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner Operand = I.getOperand(i); 1104ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner if (Operand->getType() != TheType) { 1105ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner PrintAllTypes = true; // We have differing types! Print them all! 1106ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner break; 1107ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner } 1108009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1109009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1110ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner 1111c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner if (!PrintAllTypes) { 11120313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << ' '; 1113ffd9bf404cd36c93d82b0080113ccc6d230915b3Chris Lattner printType(TheType); 1114c1824996451d5ea93864fcd34ba8ea5e5f03e368Chris Lattner } 1115009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 11167e70829632f82de15db187845666aaca6e04b792Chris Lattner for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 11170313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman if (i) Out << ','; 11187e70829632f82de15db187845666aaca6e04b792Chris Lattner writeOperand(I.getOperand(i), PrintAllTypes); 1119009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1120009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1121009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1122e02fa8551d20081534afa46e0976811687e5183aChris Lattner printInfoComment(I); 11230313e0b44dcd77acd334d3f324c7da527179a690Misha Brukman Out << "\n"; 1124009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1125009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1126009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1127009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1128009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// External Interface declarations 1129009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1130009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 113195e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 11320d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(this); 113395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, this, AAW); 113475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1135009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1136009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 113775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid GlobalVariable::print(std::ostream &o) const { 11380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 113995e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), 0); 114075cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1141b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner} 1142b0e4523624fbe493a945ea73a8f3c6d6526f3f27Chris Lattner 114395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 11440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 114595e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, getParent(), AAW); 1146009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 114775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 1148009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1149009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 115095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 11510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(getParent()); 115275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner AssemblyWriter W(o, SlotTable, 115395e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner getParent() ? getParent()->getParent() : 0, AAW); 115475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 115575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1156009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 115795e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattnervoid Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 115875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner const Function *F = getParent() ? getParent()->getParent() : 0; 11590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SlotMachine SlotTable(F); 116095e5a2cc3fc55b262d2baa1cc417115dfa4a18eaChris Lattner AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1161009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 116275cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner W.write(this); 116375cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1164009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 116575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Constant::print(std::ostream &o) const { 116675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) { o << "<null> constant value\n"; return; } 11673bc06b33dac11e9372b06484139b4d4c11788273Chris Lattner 116840c732cc52a5c71cead461646667ef5b13801923Misha Brukman o << ' ' << getType()->getDescription() << ' '; 116966e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner 11707b13f56c36eb7572e1053974e5487a5f1c3080aaChris Lattner std::map<const Type *, std::string> TypeTable; 117166e810be9f97fa744ca949d54b5d54358add84b8Chris Lattner WriteConstantInt(o, this, false, TypeTable, 0); 1172009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1173009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 117475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Type::print(std::ostream &o) const { 117575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner if (this == 0) 117675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << "<null Type>"; 117775cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner else 117875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner o << getDescription(); 1179009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1180009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 118173e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattnervoid Argument::print(std::ostream &o) const { 1182144d9baf5e5665ab1b0e815402d92ee615034b01Chris Lattner WriteAsOperand(o, this, true, true, 1183144d9baf5e5665ab1b0e815402d92ee615034b01Chris Lattner getParent() ? getParent()->getParent() : 0); 118475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner} 1185009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1186fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Value::dump - allow easy printing of Values from the debugger. 1187fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 118875cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattnervoid Value::dump() const { print(std::cerr); } 1189fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer 1190fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Type::dump - allow easy printing of Values from the debugger. 1191fa452c05504ebee698e00050d04e1a43b0f21045Reid Spencer// Located here because so much of the needed functionality is here. 11929231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencervoid Type::dump() const { print(std::cerr); } 1193009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 119475cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 119575cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner// CachedWriter Class Implementation 119675cf7cf00d391ac6ca22d6240fa9d99ed427d1d5Chris Lattner//===----------------------------------------------------------------------===// 1197da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1198da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattnervoid CachedWriter::setModule(const Module *M) { 1199da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; delete AW; 1200da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner if (M) { 12010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC = new SlotMachine(M ); 120240c732cc52a5c71cead461646667ef5b13801923Misha Brukman AW = new AssemblyWriter(Out, *SC, M, 0); 1203da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } else { 1204da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner SC = 0; AW = 0; 1205da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner } 1206da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1207da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 1208da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris LattnerCachedWriter::~CachedWriter() { 1209da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete AW; 1210da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner delete SC; 1211da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 1212da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner 12130a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris LattnerCachedWriter &CachedWriter::operator<<(const Value &V) { 1214da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner assert(AW && SC && "CachedWriter does not have a current module!"); 12150a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner if (const Instruction *I = dyn_cast<Instruction>(&V)) 1216fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(I); 12170a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const BasicBlock *BB = dyn_cast<BasicBlock>(&V)) 1218fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(BB); 12190a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const Function *F = dyn_cast<Function>(&V)) 1220fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(F); 12210a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V)) 1222fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner AW->write(GV); 1223fae098a56b403e91affcb44de7e981fc9f34ea12Chris Lattner else 12240a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner AW->writeOperand(&V, true, true); 1225da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner return *this; 1226da1fbcc5c389e86840f6131afc22b45ce7e9ad08Chris Lattner} 12275cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman 12280a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris LattnerCachedWriter& CachedWriter::operator<<(const Type &Ty) { 12295cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman if (SymbolicTypes) { 12305cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman const Module *M = AW->getModule(); 12310a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner if (M) WriteTypeSymbolic(Out, &Ty, M); 12320e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 12330a8e8e1a4ea46fa5da067369ac43d8a459d0cac0Chris Lattner AW->write(&Ty); 12340e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 12350e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return *this; 12365cf1acff3c32e52d79ea8b0b47e341d4e975ed8cMisha Brukman} 1237e5242def97c52077b4e0a77a501f324867f7bce5Misha Brukman 12380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 12390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===-- SlotMachine Implementation 12400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer//===----------------------------------------------------------------------===// 12410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12420d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#if 0 12430d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) std::cerr << X 12440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#else 12450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#define SC_DEBUG(X) 12460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer#endif 12470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Module level constructor. Causes the contents of the Module (sans functions) 12490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// to be added to the slot table. 12500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid SpencerSlotMachine::SlotMachine(const Module *M) 1251b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule(M) ///< Saved for lazy initialization. 1252b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(0) 12530d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 12540e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , mTypes() 12550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 12560e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , fTypes() 12570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 12580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Function level constructor. Causes the contents of the Module and the one 12610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function provided to be added to the slot table. 12620d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid SpencerSlotMachine::SlotMachine(const Function *F ) 1263b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization 1264b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer , TheFunction(F) ///< Saved for lazy initialization 12650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , mMap() 12660e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , mTypes() 12670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer , fMap() 12680e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer , fTypes() 12690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer{ 1270b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer} 1271b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1272b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencerinline void SlotMachine::initialize(void) { 1273b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheModule) { 1274b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer processModule(); 1275b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheModule = 0; ///< Prevent re-processing next time we're called. 1276b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer } 1277b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 1278b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer processFunction(); 12790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 12800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Iterate through all the global variables, functions, and global 12830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// variable initializers and create slots for them. 12840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::processModule() { 12850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processModule!\n"); 12860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the global variables to the value table... 12880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend(); 12890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 12900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 12910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the functions to the table 12930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 12940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer I != E; ++I) 12950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 12960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 12970d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processModule!\n"); 12980d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 12990d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13000d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1301b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// Process the arguments, basic blocks, and instructions of a function. 1302b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencervoid SlotMachine::processFunction() { 13030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin processFunction!\n"); 13040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13050d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all the function arguments 1306b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer for(Function::const_aiterator AI = TheFunction->abegin(), 1307b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer AE = TheFunction->aend(); AI != AE; ++AI) 13080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(AI); 13090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("Inserting Instructions:\n"); 13110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Add all of the basic blocks and instructions 1313b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer for (Function::const_iterator BB = TheFunction->begin(), 1314b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer E = TheFunction->end(); BB != E; ++BB) { 13150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(BB); 13160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 13170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer createSlot(I); 13180d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13190d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13200d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13210d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end processFunction!\n"); 13220d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 13230d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13240d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Clean up after incorporating a function. This is the only way 1325b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// to get out of the function incorporation state that affects the 1326b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// getSlot/createSlot lock. Function incorporation state is indicated 1327b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer// by TheFunction != 0. 13280d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencervoid SlotMachine::purgeFunction() { 13290d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("begin purgeFunction!\n"); 13300d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer fMap.clear(); // Simply discard the function level map 13310e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer fTypes.clear(); 1332b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer TheFunction = 0; 13330d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("end purgeFunction!\n"); 13340d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 13350d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13360d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Get the slot number for a value. This function will assert if you 13370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// ask for a Value that hasn't previously been inserted with createSlot. 13380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer/// Types are forbidden because Type does not inherit from Value (any more). 133969566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattnerint SlotMachine::getSlot(const Value *V) { 13400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't get slot for null Value" ); 1341b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1342b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 1343b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer 1344b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Check for uninitialized state and do lazy initialization 1345b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer this->initialize(); 13460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type of the value 13480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 13490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Find the type plane in the module map 13510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 13520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1353b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 13540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the type in the function map too 13550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 13560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 13570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 13580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 13590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 13600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 13610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1362e9e326e2eb223ea4bc6762a099ce3c314e4daedbChris Lattner // Look up the value in the module map. 1363e9e326e2eb223ea4bc6762a099ce3c314e4daedbChris Lattner if (MI == mMap.end()) return -1; 1364b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1365b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 136669566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MVI == MI->second.map.end()) return -1; 1367b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert( MVI != MI->second.map.end() && "Value not found"); 1368b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1369b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 13700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 13720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1373b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1374b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1375b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1376d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner if (MI != mMap.end()) 1377d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner return MI->second.next_slot + FVI->second; 1378d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner else 1379d1cd3285601d4accf370779ac520c1e494a08b87Chris Lattner return FVI->second; 13800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13820d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 13830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1384fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer // N.B. Can get here only if either !TheFunction or the function doesn't 1385fc621e28781e3cf22f1850e07f285581334e2402Reid Spencer // have a corresponding type plane for the Value 13860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure the type plane exists 138869566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MI == mMap.end()) return -1; 13890d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 13900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 13910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Make sure we found it. 139269566459cc27c5210472a87ae2fe7b2ca64f9fc8Chris Lattner if (MVI == MI->second.map.end()) return -1; 13930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Return it. 13940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 13950d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 13960d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 13970e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// Get the slot number for a value. This function will assert if you 13980e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// ask for a Value that hasn't previously been inserted with createSlot. 13990e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer/// Types are forbidden because Type does not inherit from Value (any more). 14000e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerint SlotMachine::getSlot(const Type *Ty) { 14010e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert( Ty && "Can't get slot for null Type" ); 14020e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14030e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Check for uninitialized state and do lazy initialization 14040e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer this->initialize(); 14050e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14060e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 14070e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the Type in the function map 14080e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator FTI = fTypes.map.find(Ty); 14090e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If the Type doesn't exist in the function map 14100e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( FTI == fTypes.map.end() ) { 14110e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 14120e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If we didn't find it, it wasn't inserted 14130e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (MTI == mTypes.map.end()) 14140e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return -1; 14150e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // We found it only at the module level 14160e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 14170e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14180e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // else the value exists in the function map 14190e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 14200e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return the slot number as the module's contribution to 14210e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // the type plane plus the index in the function's contribution 14220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // to the type plane. 14230e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return mTypes.next_slot + FTI->second; 14240e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 14250e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 14260e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14270e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // N.B. Can get here only if either !TheFunction 14280e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14290e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the value in the module's map 14300e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 14310e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Make sure we found it. 14320e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if (MTI == mTypes.map.end()) return -1; 14330e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return it. 14340e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 14350e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 14360e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 14370d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Create a new slot, or return the existing slot if it is already 14380d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// inserted. Note that the logic here parallels getSlot but instead 14390d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// of asserting when the Value* isn't found, it inserts the value. 14400d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::createSlot(const Value *V) { 14410d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert( V && "Can't insert a null Value to SlotMachine"); 1442b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1443b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 14440d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14450d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type* VTy = V->getType(); 14460d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14470d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Just ignore void typed things 14480d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if (VTy == Type::VoidTy) return 0; // FIXME: Wrong return value! 14490d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14500d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Look up the type plane for the Value's type from the module map 14510d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator MI = mMap.find(VTy); 14520d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1453b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 14540d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Get the type plane for the Value's type from the function map 14550d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::const_iterator FI = fMap.find(VTy); 14560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If there is a corresponding type plane in the function map 14570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FI != fMap.end() ) { 14580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the Value in the function map 14590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator FVI = FI->second.map.find(V); 14600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the value doesn't exist in the function map 14610d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( FVI == FI->second.map.end() ) { 1462b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If there is no corresponding type plane in the module map 1463b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1464b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1465b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module map 1466b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1467b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it, it wasn't inserted 1468b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1469b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 1470b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1471b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // We found it only at the module level 1472b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 14730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14740d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else the value exists in the function map 14750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1476b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MI == mMap.end() ) 1477b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return FVI->second; 1478b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1479b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1480b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index in the function's contribution 1481b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // to the type plane. 1482b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + FVI->second; 14830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 14840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 14850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else there is not a corresponding type plane in the function map 14860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 14870d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the type plane doesn't exists at the module level 14880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI == mMap.end() ) { 1489b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return insertValue(V); 14900d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // else type plane exists at the module level, examine it 14910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 1492b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Look up the value in the module's map 1493b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 1494b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If we didn't find it there either 1495b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( MVI == MI->second.map.end() ) 1496b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // Return the slot number as the module's contribution to 1497b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // the type plane plus the index of the function map insertion. 1498b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MI->second.next_slot + insertValue(V); 1499b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer else 1500b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer return MVI->second; 15010d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15020d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15030d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15040d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1505b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // N.B. Can only get here if !TheFunction 15060d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15070d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // If the module map's type plane is not for the Value's type 15080d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MI != mMap.end() ) { 15090d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // Lookup the value in the module's map 15100d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer ValueMap::const_iterator MVI = MI->second.map.find(V); 15110d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( MVI != MI->second.map.end() ) 15120d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return MVI->second; 15130d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15140d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15150d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return insertValue(V); 15160d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15170d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15180e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// Create a new slot, or return the existing slot if it is already 15190e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// inserted. Note that the logic here parallels getSlot but instead 15200e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// of asserting when the Value* isn't found, it inserts the value. 15210e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerunsigned SlotMachine::createSlot(const Type *Ty) { 15220e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert( Ty && "Can't insert a null Type to SlotMachine"); 15230e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15240e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 15250e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the Type in the function map 15260e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator FTI = fTypes.map.find(Ty); 15270e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If the type doesn't exist in the function map 15280e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( FTI == fTypes.map.end() ) { 15290e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Look up the type in the module map 15300e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 15310e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // If we didn't find it, it wasn't inserted 15320e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( MTI == mTypes.map.end() ) 15330e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return insertValue(Ty); 15340e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer else 15350e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // We found it only at the module level 15360e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 15370e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15380e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // else the value exists in the function map 15390e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 15400e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Return the slot number as the module's contribution to 15410e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // the type plane plus the index in the function's contribution 15420e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // to the type plane. 15430e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return mTypes.next_slot + FTI->second; 15440e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 15450e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 15460e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15470e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // N.B. Can only get here if !TheFunction 15480e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15490e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer // Lookup the type in the module's map 15500e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer TypeMap::const_iterator MTI = mTypes.map.find(Ty); 15510e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( MTI != mTypes.map.end() ) 15520e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return MTI->second; 15530e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 15540e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return insertValue(Ty); 15550e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 15560d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15570d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// Low level insert function. Minimal checking is done. This 15580d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer// function is just for the convenience of createSlot (above). 15590d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencerunsigned SlotMachine::insertValue(const Value *V ) { 15600d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer assert(V && "Can't insert a null Value into SlotMachine!"); 1561b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 1562b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer "Can't insert a non-GlobalValue Constant into SlotMachine"); 15630d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1564b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer // If this value does not contribute to a plane (is void) 15650d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // or if the value already has a name then ignore it. 1566b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if (V->getType() == Type::VoidTy || V->hasName() ) { 15670d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("ignored value " << *V << "\n"); 15680d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return 0; // FIXME: Wrong return value 15690d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15700d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15710d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer const Type *VTy = V->getType(); 15720d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer unsigned DestSlot = 0; 15730d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 1574b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer if ( TheFunction ) { 15750d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = fMap.find( VTy ); 15760d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( I == fMap.end() ) 15770e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer I = fMap.insert(std::make_pair(VTy,ValuePlane())).first; 15780d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 15790d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } else { 15800d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer TypedPlanes::iterator I = mMap.find( VTy ); 15810d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer if ( I == mMap.end() ) 15820e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer I = mMap.insert(std::make_pair(VTy,ValuePlane())).first; 15830d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer DestSlot = I->second.map[V] = I->second.next_slot++; 15840d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer } 15850d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15860d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1587b03de0c780a74d63f6b331eb8f615b46c4cddd7bReid Spencer DestSlot << " ["); 15880d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer // G = Global, C = Constant, T = Type, F = Function, o = other 15897970396014eacbe719eb171448ddc546c1ad2289Reid Spencer SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : 15907970396014eacbe719eb171448ddc546c1ad2289Reid Spencer (isa<Constant>(V) ? 'C' : 'o')))); 15910d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer SC_DEBUG("]\n"); 15920d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer return DestSlot; 15930d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer} 15940d1b77e2824115d97f8392c3f4ec257b27ebbd7aReid Spencer 15950e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// Low level insert function. Minimal checking is done. This 15960e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer// function is just for the convenience of createSlot (above). 15970e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencerunsigned SlotMachine::insertValue(const Type *Ty ) { 15980e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer assert(Ty && "Can't insert a null Type into SlotMachine!"); 15990e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16000e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer unsigned DestSlot = 0; 16010e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16020e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer if ( TheFunction ) { 16030e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer DestSlot = fTypes.map[Ty] = fTypes.next_slot++; 16040e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } else { 16050e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer DestSlot = fTypes.map[Ty] = fTypes.next_slot++; 16060e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer } 16070e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer SC_DEBUG(" Inserting type [" << DestSlot << "] = " << Ty << "\n"); 16080e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer return DestSlot; 16090e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer} 16100e25e1cdcf1f73bb9f56b91155d5c0ef42ef0a44Reid Spencer 16119231ac8b6f2c3f9877bdb7a223f7392061258ab6Reid Spencer// vim: sw=2 1612