blob: 63ec8e423e5d8a5c4c67958deb6d506069ee7dd9 [file] [log] [blame]
Chris Lattnerf7e79482002-04-07 22:31:46 +00001//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
Misha Brukmanb1c93172005-04-21 23:48:37 +00002//
John Criswell482202a2003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
Misha Brukmanb1c93172005-04-21 23:48:37 +00007//
John Criswell482202a2003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattner2f7c9632001-06-06 20:29:01 +00009//
10// This library implements the functionality defined in llvm/Assembly/Writer.h
11//
Chris Lattner189088e2002-04-12 18:21:53 +000012// Note that these routines must be extremely tolerant of various errors in the
Chris Lattnerf70da102003-05-08 02:44:12 +000013// LLVM code, because it can be used for debugging transformations.
Chris Lattner189088e2002-04-12 18:21:53 +000014//
Chris Lattner2f7c9632001-06-06 20:29:01 +000015//===----------------------------------------------------------------------===//
16
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +000017#include "llvm/Assembly/Writer.h"
Chris Lattner7f8845a2002-07-23 18:07:49 +000018#include "llvm/Assembly/PrintModulePass.h"
Chris Lattner8339f7d2003-10-30 23:41:03 +000019#include "llvm/Assembly/AsmAnnotationWriter.h"
Chris Lattnerf7b6d312005-05-06 20:26:43 +000020#include "llvm/CallingConv.h"
Chris Lattnerc70b3f62004-01-20 19:50:34 +000021#include "llvm/Constants.h"
Chris Lattner913d18f2002-04-29 18:46:50 +000022#include "llvm/DerivedTypes.h"
Reid Spencer1517de32007-04-09 06:10:42 +000023#include "llvm/ParameterAttributes.h"
Chris Lattner8bbcda22006-01-25 18:57:27 +000024#include "llvm/InlineAsm.h"
Vikram S. Adveb952b542002-07-14 23:14:45 +000025#include "llvm/Instruction.h"
Misha Brukman2d3fa9e2004-07-29 16:53:53 +000026#include "llvm/Instructions.h"
Chris Lattnerc70b3f62004-01-20 19:50:34 +000027#include "llvm/Module.h"
Reid Spencer3aaaa0b2007-02-05 20:47:22 +000028#include "llvm/ValueSymbolTable.h"
Reid Spencer32af9e82007-01-06 07:24:44 +000029#include "llvm/TypeSymbolTable.h"
Reid Spencer7c16caa2004-09-01 22:55:40 +000030#include "llvm/ADT/StringExtras.h"
31#include "llvm/ADT/STLExtras.h"
Bill Wendlingdfc91892006-11-28 02:09:03 +000032#include "llvm/Support/CFG.h"
Jim Laskeyb74c6662005-08-17 19:34:49 +000033#include "llvm/Support/MathExtras.h"
Bill Wendlingdfc91892006-11-28 02:09:03 +000034#include "llvm/Support/Streams.h"
Chris Lattnerfee714f2001-09-07 16:36:04 +000035#include <algorithm>
Chris Lattner189d19f2003-11-21 20:23:48 +000036using namespace llvm;
Brian Gaeke960707c2003-11-11 22:41:34 +000037
Chris Lattner60a7dd12004-07-15 02:51:31 +000038namespace llvm {
Reid Spencer16f2f7f2004-05-26 07:18:52 +000039
Reid Spencer294715b2005-05-15 16:13:11 +000040// Make virtual table appear in this compilation unit.
41AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
42
Reid Spencer16f2f7f2004-05-26 07:18:52 +000043/// This class provides computation of slot numbers for LLVM Assembly writing.
44/// @brief LLVM Assembly Writing Slot Computation.
45class SlotMachine {
46
47/// @name Types
48/// @{
49public:
50
51 /// @brief A mapping of Values to slot numbers
Reid Spencer50816782007-03-19 18:32:53 +000052 typedef std::map<const Value*,unsigned> ValueMap;
Reid Spencer16f2f7f2004-05-26 07:18:52 +000053
54/// @}
55/// @name Constructors
56/// @{
57public:
58 /// @brief Construct from a module
Chris Lattner23e829a2006-12-06 05:12:21 +000059 SlotMachine(const Module *M);
Reid Spencer16f2f7f2004-05-26 07:18:52 +000060
61 /// @brief Construct from a function, starting out in incorp state.
Chris Lattner23e829a2006-12-06 05:12:21 +000062 SlotMachine(const Function *F);
Reid Spencer16f2f7f2004-05-26 07:18:52 +000063
64/// @}
65/// @name Accessors
66/// @{
67public:
68 /// Return the slot number of the specified value in it's type
Chris Lattner5e043322007-01-11 03:54:27 +000069 /// plane. If something is not in the SlotMachine, return -1.
70 int getLocalSlot(const Value *V);
71 int getGlobalSlot(const GlobalValue *V);
Reid Spencer8beac692004-06-09 15:26:53 +000072
Reid Spencer16f2f7f2004-05-26 07:18:52 +000073/// @}
74/// @name Mutators
75/// @{
76public:
Misha Brukmanb1c93172005-04-21 23:48:37 +000077 /// If you'd like to deal with a function instead of just a module, use
Reid Spencer16f2f7f2004-05-26 07:18:52 +000078 /// this method to get its data into the SlotMachine.
Misha Brukmanb1c93172005-04-21 23:48:37 +000079 void incorporateFunction(const Function *F) {
80 TheFunction = F;
Reid Spencerb0ac8c42004-08-16 07:46:33 +000081 FunctionProcessed = false;
82 }
Reid Spencer16f2f7f2004-05-26 07:18:52 +000083
Misha Brukmanb1c93172005-04-21 23:48:37 +000084 /// After calling incorporateFunction, use this method to remove the
85 /// most recently incorporated function from the SlotMachine. This
Reid Spencer16f2f7f2004-05-26 07:18:52 +000086 /// will reset the state of the machine back to just the module contents.
87 void purgeFunction();
88
89/// @}
90/// @name Implementation Details
91/// @{
92private:
Reid Spencer56010e42004-05-26 21:56:09 +000093 /// This function does the actual initialization.
94 inline void initialize();
95
Chris Lattnerea862a32007-01-09 07:55:49 +000096 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
97 void CreateModuleSlot(const GlobalValue *V);
98
99 /// CreateFunctionSlot - Insert the specified Value* into the slot table.
100 void CreateFunctionSlot(const Value *V);
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000101
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000102 /// Add all of the module level global variables (and their initializers)
103 /// and function declarations, but not the contents of those functions.
104 void processModule();
105
Reid Spencer56010e42004-05-26 21:56:09 +0000106 /// Add all of the functions arguments, basic blocks, and instructions
107 void processFunction();
108
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000109 SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT
110 void operator=(const SlotMachine &); // DO NOT IMPLEMENT
111
112/// @}
113/// @name Data
114/// @{
115public:
116
117 /// @brief The module for which we are holding slot numbers
Reid Spencer56010e42004-05-26 21:56:09 +0000118 const Module* TheModule;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000119
Reid Spencer56010e42004-05-26 21:56:09 +0000120 /// @brief The function for which we are holding slot numbers
121 const Function* TheFunction;
Reid Spencerb0ac8c42004-08-16 07:46:33 +0000122 bool FunctionProcessed;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000123
124 /// @brief The TypePlanes map for the module level data
Reid Spencer50816782007-03-19 18:32:53 +0000125 ValueMap mMap;
126 unsigned mNext;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000127
128 /// @brief The TypePlanes map for the function level data
Reid Spencer50816782007-03-19 18:32:53 +0000129 ValueMap fMap;
130 unsigned fNext;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000131
132/// @}
133
134};
135
Chris Lattner60a7dd12004-07-15 02:51:31 +0000136} // end namespace llvm
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000137
Chris Lattnerc2d3d312006-08-27 22:42:52 +0000138static RegisterPass<PrintModulePass>
Chris Lattnere7134c52006-08-21 17:20:01 +0000139X("printm", "Print module to stderr");
Chris Lattnerc2d3d312006-08-27 22:42:52 +0000140static RegisterPass<PrintFunctionPass>
Chris Lattnere7134c52006-08-21 17:20:01 +0000141Y("print","Print function to stderr");
Chris Lattner7f8845a2002-07-23 18:07:49 +0000142
Misha Brukmanb1c93172005-04-21 23:48:37 +0000143static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
Chris Lattnera9f0a112006-12-06 05:50:41 +0000144 std::map<const Type *, std::string> &TypeTable,
Reid Spencer58d30f22004-07-04 11:50:43 +0000145 SlotMachine *Machine);
146
Chris Lattnerb86620e2001-10-29 16:37:48 +0000147static const Module *getModuleFromVal(const Value *V) {
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000148 if (const Argument *MA = dyn_cast<Argument>(V))
Chris Lattnerb86620e2001-10-29 16:37:48 +0000149 return MA->getParent() ? MA->getParent()->getParent() : 0;
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000150 else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
Chris Lattnerb86620e2001-10-29 16:37:48 +0000151 return BB->getParent() ? BB->getParent()->getParent() : 0;
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000152 else if (const Instruction *I = dyn_cast<Instruction>(V)) {
Chris Lattner57698e22002-03-26 18:01:55 +0000153 const Function *M = I->getParent() ? I->getParent()->getParent() : 0;
Chris Lattnerb86620e2001-10-29 16:37:48 +0000154 return M ? M->getParent() : 0;
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000155 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
Chris Lattnerb86620e2001-10-29 16:37:48 +0000156 return GV->getParent();
Chris Lattnerb86620e2001-10-29 16:37:48 +0000157 return 0;
158}
159
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000160static SlotMachine *createSlotMachine(const Value *V) {
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000161 if (const Argument *FA = dyn_cast<Argument>(V)) {
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000162 return new SlotMachine(FA->getParent());
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000163 } else if (const Instruction *I = dyn_cast<Instruction>(V)) {
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000164 return new SlotMachine(I->getParent()->getParent());
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000165 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000166 return new SlotMachine(BB->getParent());
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000167 } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000168 return new SlotMachine(GV->getParent());
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000169 } else if (const Function *Func = dyn_cast<Function>(V)) {
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000170 return new SlotMachine(Func);
Chris Lattner7bfee412001-10-29 16:05:51 +0000171 }
172 return 0;
173}
Chris Lattner2f7c9632001-06-06 20:29:01 +0000174
Reid Spencer788e3172007-01-26 08:02:52 +0000175/// NameNeedsQuotes - Return true if the specified llvm name should be wrapped
176/// with ""'s.
177static bool NameNeedsQuotes(const std::string &Name) {
178 if (Name[0] >= '0' && Name[0] <= '9') return true;
Chris Lattner1c343042003-08-22 05:40:38 +0000179 // Scan to see if we have any characters that are not on the "white list"
180 for (unsigned i = 0, e = Name.size(); i != e; ++i) {
181 char C = Name[i];
182 assert(C != '"' && "Illegal character in LLVM value name!");
183 if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') &&
184 C != '-' && C != '.' && C != '_')
Reid Spencer788e3172007-01-26 08:02:52 +0000185 return true;
186 }
187 return false;
188}
189
190enum PrefixType {
191 GlobalPrefix,
192 LabelPrefix,
193 LocalPrefix
194};
195
196/// getLLVMName - Turn the specified string into an 'LLVM name', which is either
197/// prefixed with % (if the string only contains simple characters) or is
198/// surrounded with ""'s (if it has special chars in it).
199static std::string getLLVMName(const std::string &Name, PrefixType Prefix) {
200 assert(!Name.empty() && "Cannot get empty name!");
201
202 // First character cannot start with a number...
203 if (NameNeedsQuotes(Name)) {
204 if (Prefix == GlobalPrefix)
205 return "@\"" + Name + "\"";
206 return "\"" + Name + "\"";
Chris Lattner1c343042003-08-22 05:40:38 +0000207 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000208
Chris Lattner1c343042003-08-22 05:40:38 +0000209 // If we get here, then the identifier is legal to use as a "VarID".
Reid Spencer788e3172007-01-26 08:02:52 +0000210 switch (Prefix) {
211 default: assert(0 && "Bad prefix!");
212 case GlobalPrefix: return '@' + Name;
213 case LabelPrefix: return Name;
214 case LocalPrefix: return '%' + Name;
215 }
Chris Lattner1c343042003-08-22 05:40:38 +0000216}
217
Chris Lattnerb86620e2001-10-29 16:37:48 +0000218
Misha Brukmanc566ca362004-03-02 00:22:19 +0000219/// fillTypeNameTable - If the module has a symbol table, take all global types
220/// and stuff their names into the TypeNames map.
221///
Chris Lattnerb86620e2001-10-29 16:37:48 +0000222static void fillTypeNameTable(const Module *M,
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000223 std::map<const Type *, std::string> &TypeNames) {
Chris Lattner98cf1f52002-11-20 18:36:02 +0000224 if (!M) return;
Reid Spencer32af9e82007-01-06 07:24:44 +0000225 const TypeSymbolTable &ST = M->getTypeSymbolTable();
226 TypeSymbolTable::const_iterator TI = ST.begin();
227 for (; TI != ST.end(); ++TI) {
Reid Spencere7e96712004-05-25 08:53:40 +0000228 // As a heuristic, don't insert pointer to primitive types, because
229 // they are used too often to have a single useful name.
230 //
231 const Type *Ty = cast<Type>(TI->second);
232 if (!isa<PointerType>(Ty) ||
Reid Spencer56010e42004-05-26 21:56:09 +0000233 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() ||
Chris Lattner03c49532007-01-15 02:27:26 +0000234 !cast<PointerType>(Ty)->getElementType()->isInteger() ||
Reid Spencer56010e42004-05-26 21:56:09 +0000235 isa<OpaqueType>(cast<PointerType>(Ty)->getElementType()))
Reid Spencer788e3172007-01-26 08:02:52 +0000236 TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first, LocalPrefix)));
Chris Lattnerb86620e2001-10-29 16:37:48 +0000237 }
238}
239
240
241
Misha Brukmanb1c93172005-04-21 23:48:37 +0000242static void calcTypeName(const Type *Ty,
John Criswellcd116ba2004-06-01 14:54:08 +0000243 std::vector<const Type *> &TypeStack,
244 std::map<const Type *, std::string> &TypeNames,
245 std::string & Result){
Chris Lattner03c49532007-01-15 02:27:26 +0000246 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) {
John Criswellcd116ba2004-06-01 14:54:08 +0000247 Result += Ty->getDescription(); // Base case
248 return;
249 }
Chris Lattnerb86620e2001-10-29 16:37:48 +0000250
251 // Check to see if the type is named.
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000252 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
John Criswellcd116ba2004-06-01 14:54:08 +0000253 if (I != TypeNames.end()) {
254 Result += I->second;
255 return;
256 }
Chris Lattnerb86620e2001-10-29 16:37:48 +0000257
John Criswellcd116ba2004-06-01 14:54:08 +0000258 if (isa<OpaqueType>(Ty)) {
259 Result += "opaque";
260 return;
261 }
Chris Lattnerf14ead92003-10-30 00:22:33 +0000262
Chris Lattnerb86620e2001-10-29 16:37:48 +0000263 // Check to see if the Type is already on the stack...
264 unsigned Slot = 0, CurSize = TypeStack.size();
265 while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type
266
Misha Brukmanb1c93172005-04-21 23:48:37 +0000267 // This is another base case for the recursion. In this case, we know
Chris Lattnerb86620e2001-10-29 16:37:48 +0000268 // that we have looped back to a type that we have previously visited.
269 // Generate the appropriate upreference to handle this.
John Criswellcd116ba2004-06-01 14:54:08 +0000270 if (Slot < CurSize) {
271 Result += "\\" + utostr(CurSize-Slot); // Here's the upreference
272 return;
273 }
Chris Lattnerb86620e2001-10-29 16:37:48 +0000274
275 TypeStack.push_back(Ty); // Recursive case: Add us to the stack..
Misha Brukmanb1c93172005-04-21 23:48:37 +0000276
Chris Lattner6b727592004-06-17 18:19:28 +0000277 switch (Ty->getTypeID()) {
Reid Spencer7a9c62b2007-01-12 07:05:14 +0000278 case Type::IntegerTyID: {
279 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
Reid Spencerc8721592007-01-12 07:25:20 +0000280 Result += "i" + utostr(BitWidth);
Reid Spencer7a9c62b2007-01-12 07:05:14 +0000281 break;
282 }
Chris Lattner91db5822002-03-29 03:44:36 +0000283 case Type::FunctionTyID: {
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000284 const FunctionType *FTy = cast<FunctionType>(Ty);
John Criswellcd116ba2004-06-01 14:54:08 +0000285 calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result);
286 Result += " (";
Reid Spencer8c4914c2006-12-31 05:24:50 +0000287 unsigned Idx = 1;
Reid Spencer1517de32007-04-09 06:10:42 +0000288 const ParamAttrsList *Attrs = FTy->getParamAttrs();
Chris Lattnerfa829be2004-02-09 04:14:01 +0000289 for (FunctionType::param_iterator I = FTy->param_begin(),
290 E = FTy->param_end(); I != E; ++I) {
291 if (I != FTy->param_begin())
Chris Lattnerb86620e2001-10-29 16:37:48 +0000292 Result += ", ";
John Criswellcd116ba2004-06-01 14:54:08 +0000293 calcTypeName(*I, TypeStack, TypeNames, Result);
Reid Spencera472f662007-04-11 02:44:20 +0000294 if (Attrs && Attrs->getParamAttrs(Idx) != ParamAttr::None) {
Reid Spencer8c4914c2006-12-31 05:24:50 +0000295 Result += + " ";
Reid Spencer1517de32007-04-09 06:10:42 +0000296 Result += Attrs->getParamAttrsTextByIndex(Idx);
Reid Spencer8c4914c2006-12-31 05:24:50 +0000297 }
298 Idx++;
Chris Lattnerb86620e2001-10-29 16:37:48 +0000299 }
Chris Lattnerd816b532002-04-13 20:53:41 +0000300 if (FTy->isVarArg()) {
Chris Lattnerfa829be2004-02-09 04:14:01 +0000301 if (FTy->getNumParams()) Result += ", ";
Chris Lattnerb86620e2001-10-29 16:37:48 +0000302 Result += "...";
303 }
304 Result += ")";
Reid Spencera472f662007-04-11 02:44:20 +0000305 if (Attrs && Attrs->getParamAttrs(0) != ParamAttr::None) {
Reid Spencer136a91c2007-01-05 17:06:19 +0000306 Result += " ";
Reid Spencer1517de32007-04-09 06:10:42 +0000307 Result += Attrs->getParamAttrsTextByIndex(0);
Reid Spencer136a91c2007-01-05 17:06:19 +0000308 }
Chris Lattnerb86620e2001-10-29 16:37:48 +0000309 break;
310 }
311 case Type::StructTyID: {
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000312 const StructType *STy = cast<StructType>(Ty);
Andrew Lenharthdcb3c972006-12-08 18:06:16 +0000313 if (STy->isPacked())
314 Result += '<';
John Criswellcd116ba2004-06-01 14:54:08 +0000315 Result += "{ ";
Chris Lattnerac6db752004-02-09 04:37:31 +0000316 for (StructType::element_iterator I = STy->element_begin(),
317 E = STy->element_end(); I != E; ++I) {
318 if (I != STy->element_begin())
Chris Lattnerb86620e2001-10-29 16:37:48 +0000319 Result += ", ";
John Criswellcd116ba2004-06-01 14:54:08 +0000320 calcTypeName(*I, TypeStack, TypeNames, Result);
Chris Lattnerb86620e2001-10-29 16:37:48 +0000321 }
322 Result += " }";
Andrew Lenharthdcb3c972006-12-08 18:06:16 +0000323 if (STy->isPacked())
324 Result += '>';
Chris Lattnerb86620e2001-10-29 16:37:48 +0000325 break;
326 }
327 case Type::PointerTyID:
Misha Brukmanb1c93172005-04-21 23:48:37 +0000328 calcTypeName(cast<PointerType>(Ty)->getElementType(),
John Criswellcd116ba2004-06-01 14:54:08 +0000329 TypeStack, TypeNames, Result);
330 Result += "*";
Chris Lattnerb86620e2001-10-29 16:37:48 +0000331 break;
332 case Type::ArrayTyID: {
Chris Lattnerf26a8ee2003-07-23 15:30:06 +0000333 const ArrayType *ATy = cast<ArrayType>(Ty);
John Criswellcd116ba2004-06-01 14:54:08 +0000334 Result += "[" + utostr(ATy->getNumElements()) + " x ";
335 calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result);
336 Result += "]";
Chris Lattnerb86620e2001-10-29 16:37:48 +0000337 break;
338 }
Reid Spencerd84d35b2007-02-15 02:26:10 +0000339 case Type::VectorTyID: {
340 const VectorType *PTy = cast<VectorType>(Ty);
Brian Gaeke02209042004-08-20 06:00:58 +0000341 Result += "<" + utostr(PTy->getNumElements()) + " x ";
342 calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result);
343 Result += ">";
344 break;
345 }
Chris Lattner15285ab2003-05-14 17:50:47 +0000346 case Type::OpaqueTyID:
John Criswellcd116ba2004-06-01 14:54:08 +0000347 Result += "opaque";
Chris Lattner15285ab2003-05-14 17:50:47 +0000348 break;
Chris Lattnerb86620e2001-10-29 16:37:48 +0000349 default:
John Criswellcd116ba2004-06-01 14:54:08 +0000350 Result += "<unrecognized-type>";
Chris Lattnerfc9f1c92006-12-06 06:40:49 +0000351 break;
Chris Lattnerb86620e2001-10-29 16:37:48 +0000352 }
353
354 TypeStack.pop_back(); // Remove self from stack...
Chris Lattnerb86620e2001-10-29 16:37:48 +0000355}
356
357
Misha Brukmanb22d09c2004-03-01 19:48:13 +0000358/// printTypeInt - The internal guts of printing out a type that has a
359/// potentially named portion.
360///
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000361static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,
362 std::map<const Type *, std::string> &TypeNames) {
Chris Lattnerb86620e2001-10-29 16:37:48 +0000363 // Primitive types always print out their description, regardless of whether
364 // they have been named or not.
365 //
Chris Lattner03c49532007-01-15 02:27:26 +0000366 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)))
Chris Lattner92d60532003-10-30 00:12:51 +0000367 return Out << Ty->getDescription();
Chris Lattnerb86620e2001-10-29 16:37:48 +0000368
369 // Check to see if the type is named.
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000370 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
Chris Lattnerb86620e2001-10-29 16:37:48 +0000371 if (I != TypeNames.end()) return Out << I->second;
372
373 // Otherwise we have a type that has not been named but is a derived type.
374 // Carefully recurse the type hierarchy to print out any contained symbolic
375 // names.
376 //
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000377 std::vector<const Type *> TypeStack;
John Criswellcd116ba2004-06-01 14:54:08 +0000378 std::string TypeName;
379 calcTypeName(Ty, TypeStack, TypeNames, TypeName);
Chris Lattner7f74a562002-01-20 22:54:45 +0000380 TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use
John Criswellcd116ba2004-06-01 14:54:08 +0000381 return (Out << TypeName);
Chris Lattnerb86620e2001-10-29 16:37:48 +0000382}
383
Chris Lattner34b95182001-10-31 04:33:19 +0000384
Misha Brukmanb22d09c2004-03-01 19:48:13 +0000385/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
386/// type, iff there is an entry in the modules symbol table for the specified
387/// type or one of it's component types. This is slower than a simple x << Type
388///
Chris Lattner189d19f2003-11-21 20:23:48 +0000389std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
390 const Module *M) {
Misha Brukmanb1c93172005-04-21 23:48:37 +0000391 Out << ' ';
Chris Lattnerb86620e2001-10-29 16:37:48 +0000392
Chris Lattnerfc9f1c92006-12-06 06:40:49 +0000393 // If they want us to print out a type, but there is no context, we can't
394 // print it symbolically.
395 if (!M)
Chris Lattner72f866e2001-10-29 16:40:32 +0000396 return Out << Ty->getDescription();
Chris Lattnerfc9f1c92006-12-06 06:40:49 +0000397
398 std::map<const Type *, std::string> TypeNames;
399 fillTypeNameTable(M, TypeNames);
400 return printTypeInt(Out, Ty, TypeNames);
Chris Lattnerb86620e2001-10-29 16:37:48 +0000401}
402
Chris Lattner6ed87bd2006-01-23 23:03:36 +0000403// PrintEscapedString - Print each character of the specified string, escaping
404// it if it is not printable or if it is an escape char.
405static void PrintEscapedString(const std::string &Str, std::ostream &Out) {
406 for (unsigned i = 0, e = Str.size(); i != e; ++i) {
407 unsigned char C = Str[i];
408 if (isprint(C) && C != '"' && C != '\\') {
409 Out << C;
410 } else {
411 Out << '\\'
412 << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
413 << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
414 }
415 }
416}
417
Chris Lattnerfc9f1c92006-12-06 06:40:49 +0000418static const char *getPredicateText(unsigned predicate) {
Reid Spencer812a1be2006-12-04 05:19:18 +0000419 const char * pred = "unknown";
420 switch (predicate) {
421 case FCmpInst::FCMP_FALSE: pred = "false"; break;
422 case FCmpInst::FCMP_OEQ: pred = "oeq"; break;
423 case FCmpInst::FCMP_OGT: pred = "ogt"; break;
424 case FCmpInst::FCMP_OGE: pred = "oge"; break;
425 case FCmpInst::FCMP_OLT: pred = "olt"; break;
426 case FCmpInst::FCMP_OLE: pred = "ole"; break;
427 case FCmpInst::FCMP_ONE: pred = "one"; break;
428 case FCmpInst::FCMP_ORD: pred = "ord"; break;
429 case FCmpInst::FCMP_UNO: pred = "uno"; break;
430 case FCmpInst::FCMP_UEQ: pred = "ueq"; break;
431 case FCmpInst::FCMP_UGT: pred = "ugt"; break;
432 case FCmpInst::FCMP_UGE: pred = "uge"; break;
433 case FCmpInst::FCMP_ULT: pred = "ult"; break;
434 case FCmpInst::FCMP_ULE: pred = "ule"; break;
435 case FCmpInst::FCMP_UNE: pred = "une"; break;
436 case FCmpInst::FCMP_TRUE: pred = "true"; break;
437 case ICmpInst::ICMP_EQ: pred = "eq"; break;
438 case ICmpInst::ICMP_NE: pred = "ne"; break;
439 case ICmpInst::ICMP_SGT: pred = "sgt"; break;
440 case ICmpInst::ICMP_SGE: pred = "sge"; break;
441 case ICmpInst::ICMP_SLT: pred = "slt"; break;
442 case ICmpInst::ICMP_SLE: pred = "sle"; break;
443 case ICmpInst::ICMP_UGT: pred = "ugt"; break;
444 case ICmpInst::ICMP_UGE: pred = "uge"; break;
445 case ICmpInst::ICMP_ULT: pred = "ult"; break;
446 case ICmpInst::ICMP_ULE: pred = "ule"; break;
447 }
448 return pred;
449}
450
Misha Brukmanb1c93172005-04-21 23:48:37 +0000451/// @brief Internal constant writer.
452static void WriteConstantInt(std::ostream &Out, const Constant *CV,
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000453 std::map<const Type *, std::string> &TypeTable,
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000454 SlotMachine *Machine) {
Jim Laskey6be3d8e2006-02-27 10:33:53 +0000455 const int IndentSize = 4;
456 static std::string Indent = "\n";
Zhou Sheng75b871f2007-01-11 12:24:14 +0000457 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
Reid Spencer542964f2007-01-11 18:21:29 +0000458 if (CI->getType() == Type::Int1Ty)
Reid Spencercddc9df2007-01-12 04:24:46 +0000459 Out << (CI->getZExtValue() ? "true" : "false");
460 else
Reid Spencere2eb1fa2007-02-27 20:25:25 +0000461 Out << CI->getValue().toStringSigned(10);
Chris Lattner1e194682002-04-18 18:53:13 +0000462 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
463 // We would like to output the FP constant value in exponential notation,
464 // but we cannot do this if doing so will lose precision. Check here to
465 // make sure that we only output it in exponential format if we can parse
466 // the value back and get the same value.
467 //
468 std::string StrVal = ftostr(CFP->getValue());
469
470 // Check to make sure that the stringized number is not some string like
471 // "Inf" or NaN, that atof will accept, but the lexer will not. Check that
472 // the string matches the "[-+]?[0-9]" regex.
473 //
474 if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
475 ((StrVal[0] == '-' || StrVal[0] == '+') &&
Brian Gaeke87b4f072003-06-17 23:55:35 +0000476 (StrVal[1] >= '0' && StrVal[1] <= '9')))
Chris Lattner1e194682002-04-18 18:53:13 +0000477 // Reparse stringized version!
478 if (atof(StrVal.c_str()) == CFP->getValue()) {
Chris Lattner472cc102005-01-04 01:56:57 +0000479 Out << StrVal;
480 return;
Chris Lattner1e194682002-04-18 18:53:13 +0000481 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000482
Chris Lattner1e194682002-04-18 18:53:13 +0000483 // Otherwise we could not reparse it to exactly the same value, so we must
484 // output the string in hexadecimal format!
Chris Lattner472cc102005-01-04 01:56:57 +0000485 assert(sizeof(double) == sizeof(uint64_t) &&
Chris Lattner1e194682002-04-18 18:53:13 +0000486 "assuming that double is 64 bits!");
Jim Laskeyb74c6662005-08-17 19:34:49 +0000487 Out << "0x" << utohexstr(DoubleToBits(CFP->getValue()));
Chris Lattner1e194682002-04-18 18:53:13 +0000488
Chris Lattner76b2ff42004-02-15 05:55:15 +0000489 } else if (isa<ConstantAggregateZero>(CV)) {
490 Out << "zeroinitializer";
Chris Lattner1e194682002-04-18 18:53:13 +0000491 } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
492 // As a special case, print the array as a string if it is an array of
493 // ubytes or an array of sbytes with positive values.
Misha Brukmanb1c93172005-04-21 23:48:37 +0000494 //
Chris Lattner1e194682002-04-18 18:53:13 +0000495 const Type *ETy = CA->getType()->getElementType();
Chris Lattner6ed87bd2006-01-23 23:03:36 +0000496 if (CA->isString()) {
Chris Lattner1e194682002-04-18 18:53:13 +0000497 Out << "c\"";
Chris Lattner6ed87bd2006-01-23 23:03:36 +0000498 PrintEscapedString(CA->getAsString(), Out);
Chris Lattner1e194682002-04-18 18:53:13 +0000499 Out << "\"";
500
501 } else { // Cannot output in string format...
Misha Brukman21bbdb92004-06-04 21:11:51 +0000502 Out << '[';
Chris Lattnerd84bb632002-04-16 21:36:08 +0000503 if (CA->getNumOperands()) {
Misha Brukman21bbdb92004-06-04 21:11:51 +0000504 Out << ' ';
Chris Lattner1e194682002-04-18 18:53:13 +0000505 printTypeInt(Out, ETy, TypeTable);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000506 WriteAsOperandInternal(Out, CA->getOperand(0),
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000507 TypeTable, Machine);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000508 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
509 Out << ", ";
Chris Lattner1e194682002-04-18 18:53:13 +0000510 printTypeInt(Out, ETy, TypeTable);
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000511 WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000512 }
513 }
514 Out << " ]";
515 }
516 } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
Andrew Lenharth0d124b82007-01-08 18:21:30 +0000517 if (CS->getType()->isPacked())
518 Out << '<';
Misha Brukman21bbdb92004-06-04 21:11:51 +0000519 Out << '{';
Jim Laskey3bb78742006-02-25 12:27:03 +0000520 unsigned N = CS->getNumOperands();
521 if (N) {
Jim Laskey6be3d8e2006-02-27 10:33:53 +0000522 if (N > 2) {
523 Indent += std::string(IndentSize, ' ');
524 Out << Indent;
525 } else {
526 Out << ' ';
527 }
Chris Lattnerd84bb632002-04-16 21:36:08 +0000528 printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
529
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000530 WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000531
Jim Laskey3bb78742006-02-25 12:27:03 +0000532 for (unsigned i = 1; i < N; i++) {
Chris Lattnerd84bb632002-04-16 21:36:08 +0000533 Out << ", ";
Jim Laskey6be3d8e2006-02-27 10:33:53 +0000534 if (N > 2) Out << Indent;
Chris Lattnerd84bb632002-04-16 21:36:08 +0000535 printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
536
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000537 WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000538 }
Jim Laskey6be3d8e2006-02-27 10:33:53 +0000539 if (N > 2) Indent.resize(Indent.size() - IndentSize);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000540 }
Jim Laskey3bb78742006-02-25 12:27:03 +0000541
Chris Lattnerd84bb632002-04-16 21:36:08 +0000542 Out << " }";
Andrew Lenharth0d124b82007-01-08 18:21:30 +0000543 if (CS->getType()->isPacked())
544 Out << '>';
Reid Spencerd84d35b2007-02-15 02:26:10 +0000545 } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) {
Brian Gaeke02209042004-08-20 06:00:58 +0000546 const Type *ETy = CP->getType()->getElementType();
Misha Brukmanb1c93172005-04-21 23:48:37 +0000547 assert(CP->getNumOperands() > 0 &&
Brian Gaeke02209042004-08-20 06:00:58 +0000548 "Number of operands for a PackedConst must be > 0");
549 Out << '<';
550 Out << ' ';
551 printTypeInt(Out, ETy, TypeTable);
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000552 WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine);
Brian Gaeke02209042004-08-20 06:00:58 +0000553 for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
554 Out << ", ";
555 printTypeInt(Out, ETy, TypeTable);
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000556 WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine);
Brian Gaeke02209042004-08-20 06:00:58 +0000557 }
558 Out << " >";
Chris Lattnerd84bb632002-04-16 21:36:08 +0000559 } else if (isa<ConstantPointerNull>(CV)) {
560 Out << "null";
561
Chris Lattner5e0b9f22004-10-16 18:08:06 +0000562 } else if (isa<UndefValue>(CV)) {
563 Out << "undef";
564
Chris Lattner3cd8c562002-07-30 18:54:25 +0000565 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
Reid Spencer812a1be2006-12-04 05:19:18 +0000566 Out << CE->getOpcodeName();
567 if (CE->isCompare())
568 Out << " " << getPredicateText(CE->getPredicate());
569 Out << " (";
Misha Brukmanb1c93172005-04-21 23:48:37 +0000570
Vikram S. Adveb952b542002-07-14 23:14:45 +0000571 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
572 printTypeInt(Out, (*OI)->getType(), TypeTable);
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000573 WriteAsOperandInternal(Out, *OI, TypeTable, Machine);
Vikram S. Adveb952b542002-07-14 23:14:45 +0000574 if (OI+1 != CE->op_end())
Chris Lattner3cd8c562002-07-30 18:54:25 +0000575 Out << ", ";
Vikram S. Adveb952b542002-07-14 23:14:45 +0000576 }
Misha Brukmanb1c93172005-04-21 23:48:37 +0000577
Reid Spencer6c38f0b2006-11-27 01:05:10 +0000578 if (CE->isCast()) {
Chris Lattner83b396b2002-08-15 19:37:43 +0000579 Out << " to ";
580 printTypeInt(Out, CE->getType(), TypeTable);
581 }
Reid Spencer6c38f0b2006-11-27 01:05:10 +0000582
Misha Brukman21bbdb92004-06-04 21:11:51 +0000583 Out << ')';
Chris Lattner83b396b2002-08-15 19:37:43 +0000584
Chris Lattnerd84bb632002-04-16 21:36:08 +0000585 } else {
Vikram S. Adveb952b542002-07-14 23:14:45 +0000586 Out << "<placeholder or erroneous Constant>";
Chris Lattnerd84bb632002-04-16 21:36:08 +0000587 }
588}
589
590
Misha Brukmanc566ca362004-03-02 00:22:19 +0000591/// WriteAsOperand - Write the name of the specified value out to the specified
592/// ostream. This can be useful when you just want to print int %reg126, not
593/// the whole instruction that generated it.
594///
Misha Brukmanb1c93172005-04-21 23:48:37 +0000595static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000596 std::map<const Type*, std::string> &TypeTable,
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000597 SlotMachine *Machine) {
Misha Brukman21bbdb92004-06-04 21:11:51 +0000598 Out << ' ';
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000599 if (V->hasName())
Reid Spencer788e3172007-01-26 08:02:52 +0000600 Out << getLLVMName(V->getName(),
601 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
Reid Spenceraccd7c72004-07-17 23:47:01 +0000602 else {
603 const Constant *CV = dyn_cast<Constant>(V);
Chris Lattnera2d810d2006-01-25 22:26:05 +0000604 if (CV && !isa<GlobalValue>(CV)) {
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000605 WriteConstantInt(Out, CV, TypeTable, Machine);
Chris Lattnera2d810d2006-01-25 22:26:05 +0000606 } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
607 Out << "asm ";
608 if (IA->hasSideEffects())
609 Out << "sideeffect ";
610 Out << '"';
611 PrintEscapedString(IA->getAsmString(), Out);
612 Out << "\", \"";
613 PrintEscapedString(IA->getConstraintString(), Out);
614 Out << '"';
615 } else {
Reid Spencer788e3172007-01-26 08:02:52 +0000616 char Prefix = '%';
Chris Lattnerd84bb632002-04-16 21:36:08 +0000617 int Slot;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000618 if (Machine) {
Reid Spencer788e3172007-01-26 08:02:52 +0000619 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
Chris Lattner5e043322007-01-11 03:54:27 +0000620 Slot = Machine->getGlobalSlot(GV);
Reid Spencer788e3172007-01-26 08:02:52 +0000621 Prefix = '@';
622 } else {
Chris Lattner5e043322007-01-11 03:54:27 +0000623 Slot = Machine->getLocalSlot(V);
Reid Spencer788e3172007-01-26 08:02:52 +0000624 }
Chris Lattnerd84bb632002-04-16 21:36:08 +0000625 } else {
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000626 Machine = createSlotMachine(V);
Chris Lattner5e043322007-01-11 03:54:27 +0000627 if (Machine) {
Reid Spencer788e3172007-01-26 08:02:52 +0000628 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
Chris Lattner5e043322007-01-11 03:54:27 +0000629 Slot = Machine->getGlobalSlot(GV);
Reid Spencer788e3172007-01-26 08:02:52 +0000630 Prefix = '@';
631 } else {
Chris Lattner5e043322007-01-11 03:54:27 +0000632 Slot = Machine->getLocalSlot(V);
Reid Spencer788e3172007-01-26 08:02:52 +0000633 }
Chris Lattner5e043322007-01-11 03:54:27 +0000634 } else {
Chris Lattner757ee0b2004-06-09 19:41:19 +0000635 Slot = -1;
Chris Lattner5e043322007-01-11 03:54:27 +0000636 }
Reid Spencer56010e42004-05-26 21:56:09 +0000637 delete Machine;
Chris Lattnerd84bb632002-04-16 21:36:08 +0000638 }
Chris Lattner757ee0b2004-06-09 19:41:19 +0000639 if (Slot != -1)
Reid Spencer788e3172007-01-26 08:02:52 +0000640 Out << Prefix << Slot;
Chris Lattner757ee0b2004-06-09 19:41:19 +0000641 else
642 Out << "<badref>";
Chris Lattnerd84bb632002-04-16 21:36:08 +0000643 }
644 }
645}
646
Misha Brukmanb22d09c2004-03-01 19:48:13 +0000647/// WriteAsOperand - Write the name of the specified value out to the specified
648/// ostream. This can be useful when you just want to print int %reg126, not
649/// the whole instruction that generated it.
650///
Chris Lattner189d19f2003-11-21 20:23:48 +0000651std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
Chris Lattner0dda8612006-12-06 06:15:43 +0000652 bool PrintType, const Module *Context) {
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000653 std::map<const Type *, std::string> TypeNames;
Chris Lattner5a9f63e2002-07-10 16:48:17 +0000654 if (Context == 0) Context = getModuleFromVal(V);
Chris Lattnerb86620e2001-10-29 16:37:48 +0000655
Chris Lattner98cf1f52002-11-20 18:36:02 +0000656 if (Context)
Chris Lattner5a9f63e2002-07-10 16:48:17 +0000657 fillTypeNameTable(Context, TypeNames);
Chris Lattnerd84bb632002-04-16 21:36:08 +0000658
659 if (PrintType)
660 printTypeInt(Out, V->getType(), TypeNames);
Misha Brukmanb1c93172005-04-21 23:48:37 +0000661
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000662 WriteAsOperandInternal(Out, V, TypeNames, 0);
Chris Lattner5e5abe32001-07-20 19:15:21 +0000663 return Out;
664}
665
Reid Spencer58d30f22004-07-04 11:50:43 +0000666
Chris Lattner189d19f2003-11-21 20:23:48 +0000667namespace llvm {
Chris Lattner2e9fee42001-07-12 23:35:26 +0000668
Chris Lattnerfee714f2001-09-07 16:36:04 +0000669class AssemblyWriter {
Misha Brukmana6619a92004-06-21 21:53:56 +0000670 std::ostream &Out;
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000671 SlotMachine &Machine;
Chris Lattner7bfee412001-10-29 16:05:51 +0000672 const Module *TheModule;
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000673 std::map<const Type *, std::string> TypeNames;
Chris Lattner8339f7d2003-10-30 23:41:03 +0000674 AssemblyAnnotationWriter *AnnotationWriter;
Chris Lattner2f7c9632001-06-06 20:29:01 +0000675public:
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000676 inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M,
Chris Lattner8339f7d2003-10-30 23:41:03 +0000677 AssemblyAnnotationWriter *AAW)
Misha Brukmana6619a92004-06-21 21:53:56 +0000678 : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) {
Chris Lattner7bfee412001-10-29 16:05:51 +0000679
680 // If the module has a symbol table, take all global types and stuff their
681 // names into the TypeNames map.
682 //
Chris Lattnerb86620e2001-10-29 16:37:48 +0000683 fillTypeNameTable(M, TypeNames);
Chris Lattner2f7c9632001-06-06 20:29:01 +0000684 }
685
Chris Lattner7bfee412001-10-29 16:05:51 +0000686 inline void write(const Module *M) { printModule(M); }
687 inline void write(const GlobalVariable *G) { printGlobal(G); }
Chris Lattner57698e22002-03-26 18:01:55 +0000688 inline void write(const Function *F) { printFunction(F); }
Chris Lattner7bfee412001-10-29 16:05:51 +0000689 inline void write(const BasicBlock *BB) { printBasicBlock(BB); }
Chris Lattner113f4f42002-06-25 16:13:24 +0000690 inline void write(const Instruction *I) { printInstruction(*I); }
Chris Lattner7db79582001-11-07 04:21:57 +0000691 inline void write(const Type *Ty) { printType(Ty); }
Chris Lattner2f7c9632001-06-06 20:29:01 +0000692
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000693 void writeOperand(const Value *Op, bool PrintType);
Chris Lattner1e194682002-04-18 18:53:13 +0000694
Misha Brukman4685e262004-04-28 15:31:21 +0000695 const Module* getModule() { return TheModule; }
696
Misha Brukmand92f54a2004-11-15 19:30:05 +0000697private:
Chris Lattner7bfee412001-10-29 16:05:51 +0000698 void printModule(const Module *M);
Reid Spencer32af9e82007-01-06 07:24:44 +0000699 void printTypeSymbolTable(const TypeSymbolTable &ST);
Chris Lattner7bfee412001-10-29 16:05:51 +0000700 void printGlobal(const GlobalVariable *GV);
Chris Lattner57698e22002-03-26 18:01:55 +0000701 void printFunction(const Function *F);
Reid Spencer1517de32007-04-09 06:10:42 +0000702 void printArgument(const Argument *FA, uint16_t ParamAttrs);
Chris Lattner7bfee412001-10-29 16:05:51 +0000703 void printBasicBlock(const BasicBlock *BB);
Chris Lattner113f4f42002-06-25 16:13:24 +0000704 void printInstruction(const Instruction &I);
Chris Lattnerd816b532002-04-13 20:53:41 +0000705
706 // printType - Go to extreme measures to attempt to print out a short,
707 // symbolic version of a type name.
708 //
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000709 std::ostream &printType(const Type *Ty) {
Misha Brukmana6619a92004-06-21 21:53:56 +0000710 return printTypeInt(Out, Ty, TypeNames);
Chris Lattnerd816b532002-04-13 20:53:41 +0000711 }
712
713 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
714 // without considering any symbolic types that we may have equal to it.
715 //
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000716 std::ostream &printTypeAtLeastOneLevel(const Type *Ty);
Chris Lattner7bfee412001-10-29 16:05:51 +0000717
Chris Lattner862e3382001-10-13 06:42:36 +0000718 // printInfoComment - Print a little comment after the instruction indicating
719 // which slot it occupies.
Chris Lattner113f4f42002-06-25 16:13:24 +0000720 void printInfoComment(const Value &V);
Chris Lattner2f7c9632001-06-06 20:29:01 +0000721};
Reid Spencerf43ac622004-05-27 22:04:46 +0000722} // end of llvm namespace
Chris Lattner2f7c9632001-06-06 20:29:01 +0000723
Misha Brukmanc566ca362004-03-02 00:22:19 +0000724/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type
725/// without considering any symbolic types that we may have equal to it.
726///
Chris Lattnerab7d1ab2003-05-08 02:08:14 +0000727std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) {
Reid Spencer7a9c62b2007-01-12 07:05:14 +0000728 if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty))
729 Out << "i" << utostr(ITy->getBitWidth());
730 else if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
Reid Spencer8c4914c2006-12-31 05:24:50 +0000731 printType(FTy->getReturnType());
Reid Spencer8c4914c2006-12-31 05:24:50 +0000732 Out << " (";
733 unsigned Idx = 1;
Reid Spencer1517de32007-04-09 06:10:42 +0000734 const ParamAttrsList *Attrs = FTy->getParamAttrs();
Chris Lattnerfa829be2004-02-09 04:14:01 +0000735 for (FunctionType::param_iterator I = FTy->param_begin(),
736 E = FTy->param_end(); I != E; ++I) {
737 if (I != FTy->param_begin())
Misha Brukmana6619a92004-06-21 21:53:56 +0000738 Out << ", ";
Chris Lattnerd84bb632002-04-16 21:36:08 +0000739 printType(*I);
Reid Spencera472f662007-04-11 02:44:20 +0000740 if (Attrs && Attrs->getParamAttrs(Idx) != ParamAttr::None) {
Reid Spencer1517de32007-04-09 06:10:42 +0000741 Out << " " << Attrs->getParamAttrsTextByIndex(Idx);
Reid Spencer8c4914c2006-12-31 05:24:50 +0000742 }
743 Idx++;
Chris Lattnerd816b532002-04-13 20:53:41 +0000744 }
745 if (FTy->isVarArg()) {
Misha Brukmana6619a92004-06-21 21:53:56 +0000746 if (FTy->getNumParams()) Out << ", ";
747 Out << "...";
Chris Lattnerd816b532002-04-13 20:53:41 +0000748 }
Misha Brukmana6619a92004-06-21 21:53:56 +0000749 Out << ')';
Reid Spencera472f662007-04-11 02:44:20 +0000750 if (Attrs && Attrs->getParamAttrs(0) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +0000751 Out << ' ' << Attrs->getParamAttrsTextByIndex(0);
Chris Lattner113f4f42002-06-25 16:13:24 +0000752 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
Andrew Lenharthdcb3c972006-12-08 18:06:16 +0000753 if (STy->isPacked())
754 Out << '<';
Misha Brukmana6619a92004-06-21 21:53:56 +0000755 Out << "{ ";
Chris Lattnerac6db752004-02-09 04:37:31 +0000756 for (StructType::element_iterator I = STy->element_begin(),
757 E = STy->element_end(); I != E; ++I) {
758 if (I != STy->element_begin())
Misha Brukmana6619a92004-06-21 21:53:56 +0000759 Out << ", ";
Chris Lattnerd816b532002-04-13 20:53:41 +0000760 printType(*I);
761 }
Misha Brukmana6619a92004-06-21 21:53:56 +0000762 Out << " }";
Andrew Lenharthdcb3c972006-12-08 18:06:16 +0000763 if (STy->isPacked())
764 Out << '>';
Chris Lattner113f4f42002-06-25 16:13:24 +0000765 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
Misha Brukman21bbdb92004-06-04 21:11:51 +0000766 printType(PTy->getElementType()) << '*';
Chris Lattner113f4f42002-06-25 16:13:24 +0000767 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
Misha Brukmana6619a92004-06-21 21:53:56 +0000768 Out << '[' << ATy->getNumElements() << " x ";
Misha Brukman21bbdb92004-06-04 21:11:51 +0000769 printType(ATy->getElementType()) << ']';
Reid Spencerd84d35b2007-02-15 02:26:10 +0000770 } else if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) {
Reid Spencere203d352004-08-20 15:37:30 +0000771 Out << '<' << PTy->getNumElements() << " x ";
772 printType(PTy->getElementType()) << '>';
773 }
Reid Spencerde46e482006-11-02 20:25:50 +0000774 else if (isa<OpaqueType>(Ty)) {
Misha Brukmana6619a92004-06-21 21:53:56 +0000775 Out << "opaque";
Chris Lattnerd816b532002-04-13 20:53:41 +0000776 } else {
Vikram S. Adveb952b542002-07-14 23:14:45 +0000777 if (!Ty->isPrimitiveType())
Misha Brukmana6619a92004-06-21 21:53:56 +0000778 Out << "<unknown derived type>";
Chris Lattnerd816b532002-04-13 20:53:41 +0000779 printType(Ty);
780 }
Misha Brukmana6619a92004-06-21 21:53:56 +0000781 return Out;
Chris Lattnerd816b532002-04-13 20:53:41 +0000782}
783
784
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000785void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
786 if (Operand == 0) {
Chris Lattner08f7d0c2005-02-24 16:58:29 +0000787 Out << "<null operand!>";
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000788 } else {
789 if (PrintType) { Out << ' '; printType(Operand->getType()); }
790 WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
Chris Lattner08f7d0c2005-02-24 16:58:29 +0000791 }
Chris Lattner2f7c9632001-06-06 20:29:01 +0000792}
793
Chris Lattner2f7c9632001-06-06 20:29:01 +0000794
Chris Lattner7bfee412001-10-29 16:05:51 +0000795void AssemblyWriter::printModule(const Module *M) {
Chris Lattner4d8689e2005-03-02 23:12:40 +0000796 if (!M->getModuleIdentifier().empty() &&
Misha Brukmanb1c93172005-04-21 23:48:37 +0000797 // Don't print the ID if it will start a new line (which would
Chris Lattner4d8689e2005-03-02 23:12:40 +0000798 // require a comment char before it).
799 M->getModuleIdentifier().find('\n') == std::string::npos)
800 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
801
Owen Andersone2237542006-10-18 02:21:12 +0000802 if (!M->getDataLayout().empty())
Chris Lattner04897162006-10-22 06:06:56 +0000803 Out << "target datalayout = \"" << M->getDataLayout() << "\"\n";
Reid Spencer48f98c82004-07-25 21:44:54 +0000804 if (!M->getTargetTriple().empty())
Reid Spencerffec7df2004-07-25 21:29:43 +0000805 Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
Misha Brukmanb1c93172005-04-21 23:48:37 +0000806
Chris Lattnereef2fe72006-01-24 04:13:11 +0000807 if (!M->getModuleInlineAsm().empty()) {
Chris Lattnerefaf35d2006-01-24 00:45:30 +0000808 // Split the string into lines, to make it easier to read the .ll file.
Chris Lattnereef2fe72006-01-24 04:13:11 +0000809 std::string Asm = M->getModuleInlineAsm();
Chris Lattnerefaf35d2006-01-24 00:45:30 +0000810 size_t CurPos = 0;
811 size_t NewLine = Asm.find_first_of('\n', CurPos);
812 while (NewLine != std::string::npos) {
813 // We found a newline, print the portion of the asm string from the
814 // last newline up to this newline.
815 Out << "module asm \"";
816 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
817 Out);
818 Out << "\"\n";
819 CurPos = NewLine+1;
820 NewLine = Asm.find_first_of('\n', CurPos);
821 }
Chris Lattner3acaf5c2006-01-24 00:40:17 +0000822 Out << "module asm \"";
Chris Lattnerefaf35d2006-01-24 00:45:30 +0000823 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
Chris Lattner6ed87bd2006-01-23 23:03:36 +0000824 Out << "\"\n";
825 }
826
Chris Lattner2cdd49d2004-09-14 05:06:58 +0000827 // Loop over the dependent libraries and emit them.
Chris Lattner730cfe42004-09-14 04:51:44 +0000828 Module::lib_iterator LI = M->lib_begin();
829 Module::lib_iterator LE = M->lib_end();
Reid Spencer48f98c82004-07-25 21:44:54 +0000830 if (LI != LE) {
Chris Lattner730cfe42004-09-14 04:51:44 +0000831 Out << "deplibs = [ ";
832 while (LI != LE) {
Chris Lattner2cdd49d2004-09-14 05:06:58 +0000833 Out << '"' << *LI << '"';
Reid Spencerffec7df2004-07-25 21:29:43 +0000834 ++LI;
Chris Lattner730cfe42004-09-14 04:51:44 +0000835 if (LI != LE)
836 Out << ", ";
Reid Spencerffec7df2004-07-25 21:29:43 +0000837 }
838 Out << " ]\n";
Reid Spencercc5ff642004-07-25 18:08:18 +0000839 }
Reid Spencerb9e08772004-09-13 23:44:23 +0000840
Chris Lattner2cdd49d2004-09-14 05:06:58 +0000841 // Loop over the symbol table, emitting all named constants.
Reid Spencer32af9e82007-01-06 07:24:44 +0000842 printTypeSymbolTable(M->getTypeSymbolTable());
Misha Brukmanb1c93172005-04-21 23:48:37 +0000843
Chris Lattner54932b02006-12-06 04:41:52 +0000844 for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
845 I != E; ++I)
Chris Lattner113f4f42002-06-25 16:13:24 +0000846 printGlobal(I);
Chris Lattnerfee714f2001-09-07 16:36:04 +0000847
Chris Lattner2cdd49d2004-09-14 05:06:58 +0000848 // Output all of the functions.
Chris Lattner113f4f42002-06-25 16:13:24 +0000849 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
850 printFunction(I);
Chris Lattnerfee714f2001-09-07 16:36:04 +0000851}
852
Chris Lattner7bfee412001-10-29 16:05:51 +0000853void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
Reid Spencer788e3172007-01-26 08:02:52 +0000854 if (GV->hasName()) Out << getLLVMName(GV->getName(), GlobalPrefix) << " = ";
Chris Lattner37798642001-09-18 04:01:05 +0000855
Misha Brukmanb1c93172005-04-21 23:48:37 +0000856 if (!GV->hasInitializer())
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000857 switch (GV->getLinkage()) {
858 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
859 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
860 default: Out << "external "; break;
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000861 } else {
Chris Lattner379a8d22003-04-16 20:28:45 +0000862 switch (GV->getLinkage()) {
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000863 case GlobalValue::InternalLinkage: Out << "internal "; break;
864 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
865 case GlobalValue::WeakLinkage: Out << "weak "; break;
866 case GlobalValue::AppendingLinkage: Out << "appending "; break;
867 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
868 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break;
869 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
870 case GlobalValue::ExternalLinkage: break;
Misha Brukman70457632004-11-14 21:04:34 +0000871 case GlobalValue::GhostLinkage:
Bill Wendlingf3baad32006-12-07 01:30:32 +0000872 cerr << "GhostLinkage not allowed in AsmWriter!\n";
Misha Brukman70457632004-11-14 21:04:34 +0000873 abort();
Chris Lattner379a8d22003-04-16 20:28:45 +0000874 }
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000875 switch (GV->getVisibility()) {
Chris Lattner90d2e422007-01-15 18:28:18 +0000876 default: assert(0 && "Invalid visibility style!");
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000877 case GlobalValue::DefaultVisibility: break;
878 case GlobalValue::HiddenVisibility: Out << "hidden "; break;
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000879 }
880 }
Lauro Ramos Venancio749e4662007-04-12 18:32:50 +0000881
882 if (GV->isThreadLocal()) Out << "thread_local ";
Misha Brukmana6619a92004-06-21 21:53:56 +0000883 Out << (GV->isConstant() ? "constant " : "global ");
Chris Lattner2413b162001-12-04 00:03:30 +0000884 printType(GV->getType()->getElementType());
Chris Lattner37798642001-09-18 04:01:05 +0000885
Reid Spenceraccd7c72004-07-17 23:47:01 +0000886 if (GV->hasInitializer()) {
887 Constant* C = cast<Constant>(GV->getInitializer());
888 assert(C && "GlobalVar initializer isn't constant?");
Chris Lattner78e2e8b2006-12-06 06:24:27 +0000889 writeOperand(GV->getInitializer(), false);
Reid Spenceraccd7c72004-07-17 23:47:01 +0000890 }
Chris Lattnerf8a974d2005-11-06 06:48:53 +0000891
Chris Lattner4b96c542005-11-12 00:10:19 +0000892 if (GV->hasSection())
893 Out << ", section \"" << GV->getSection() << '"';
894 if (GV->getAlignment())
Chris Lattnerf8a974d2005-11-06 06:48:53 +0000895 Out << ", align " << GV->getAlignment();
Chris Lattner4b96c542005-11-12 00:10:19 +0000896
Chris Lattner113f4f42002-06-25 16:13:24 +0000897 printInfoComment(*GV);
Misha Brukmana6619a92004-06-21 21:53:56 +0000898 Out << "\n";
Chris Lattnerda975502001-09-10 07:58:01 +0000899}
900
Reid Spencer32af9e82007-01-06 07:24:44 +0000901void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) {
Reid Spencere7e96712004-05-25 08:53:40 +0000902 // Print the types.
Reid Spencer32af9e82007-01-06 07:24:44 +0000903 for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end();
904 TI != TE; ++TI) {
Reid Spencer788e3172007-01-26 08:02:52 +0000905 Out << "\t" << getLLVMName(TI->first, LocalPrefix) << " = type ";
Reid Spencere7e96712004-05-25 08:53:40 +0000906
907 // Make sure we print out at least one level of the type structure, so
908 // that we do not get %FILE = type %FILE
909 //
910 printTypeAtLeastOneLevel(TI->second) << "\n";
911 }
Reid Spencer32af9e82007-01-06 07:24:44 +0000912}
913
Misha Brukmanc566ca362004-03-02 00:22:19 +0000914/// printFunction - Print all aspects of a function.
915///
Chris Lattner113f4f42002-06-25 16:13:24 +0000916void AssemblyWriter::printFunction(const Function *F) {
Chris Lattner2f7c9632001-06-06 20:29:01 +0000917 // Print out the return type and name...
Misha Brukmana6619a92004-06-21 21:53:56 +0000918 Out << "\n";
Chris Lattner379a8d22003-04-16 20:28:45 +0000919
Misha Brukmana6619a92004-06-21 21:53:56 +0000920 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
Chris Lattner8339f7d2003-10-30 23:41:03 +0000921
Reid Spencer5301e7c2007-01-30 20:08:39 +0000922 if (F->isDeclaration())
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000923 switch (F->getLinkage()) {
924 case GlobalValue::DLLImportLinkage: Out << "declare dllimport "; break;
925 case GlobalValue::ExternalWeakLinkage: Out << "declare extern_weak "; break;
926 default: Out << "declare ";
927 }
Reid Spencer7ce2d2a2006-12-29 20:29:48 +0000928 else {
929 Out << "define ";
Chris Lattner379a8d22003-04-16 20:28:45 +0000930 switch (F->getLinkage()) {
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000931 case GlobalValue::InternalLinkage: Out << "internal "; break;
932 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
933 case GlobalValue::WeakLinkage: Out << "weak "; break;
934 case GlobalValue::AppendingLinkage: Out << "appending "; break;
935 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break;
936 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break;
937 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break;
Chris Lattner379a8d22003-04-16 20:28:45 +0000938 case GlobalValue::ExternalLinkage: break;
Misha Brukman70457632004-11-14 21:04:34 +0000939 case GlobalValue::GhostLinkage:
Bill Wendlingf3baad32006-12-07 01:30:32 +0000940 cerr << "GhostLinkage not allowed in AsmWriter!\n";
Misha Brukman70457632004-11-14 21:04:34 +0000941 abort();
Chris Lattner379a8d22003-04-16 20:28:45 +0000942 }
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000943 switch (F->getVisibility()) {
Chris Lattner90d2e422007-01-15 18:28:18 +0000944 default: assert(0 && "Invalid visibility style!");
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000945 case GlobalValue::DefaultVisibility: break;
946 case GlobalValue::HiddenVisibility: Out << "hidden "; break;
Anton Korobeynikova0554d92007-01-12 19:20:47 +0000947 }
Reid Spencer7ce2d2a2006-12-29 20:29:48 +0000948 }
Chris Lattner379a8d22003-04-16 20:28:45 +0000949
Chris Lattnerf7b6d312005-05-06 20:26:43 +0000950 // Print the calling convention.
951 switch (F->getCallingConv()) {
952 case CallingConv::C: break; // default
Anton Korobeynikov3c5b3df2006-09-20 22:03:51 +0000953 case CallingConv::Fast: Out << "fastcc "; break;
954 case CallingConv::Cold: Out << "coldcc "; break;
955 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
956 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
Chris Lattnerf7b6d312005-05-06 20:26:43 +0000957 default: Out << "cc" << F->getCallingConv() << " "; break;
958 }
959
Reid Spencer8c4914c2006-12-31 05:24:50 +0000960 const FunctionType *FT = F->getFunctionType();
Reid Spencer1517de32007-04-09 06:10:42 +0000961 const ParamAttrsList *Attrs = FT->getParamAttrs();
Misha Brukman21bbdb92004-06-04 21:11:51 +0000962 printType(F->getReturnType()) << ' ';
Chris Lattner5b337482003-10-18 05:57:43 +0000963 if (!F->getName().empty())
Reid Spencer788e3172007-01-26 08:02:52 +0000964 Out << getLLVMName(F->getName(), GlobalPrefix);
Chris Lattner5b337482003-10-18 05:57:43 +0000965 else
Reid Spencer788e3172007-01-26 08:02:52 +0000966 Out << "@\"\"";
Misha Brukmana6619a92004-06-21 21:53:56 +0000967 Out << '(';
Reid Spencer16f2f7f2004-05-26 07:18:52 +0000968 Machine.incorporateFunction(F);
Chris Lattnerfee714f2001-09-07 16:36:04 +0000969
Chris Lattner7bfee412001-10-29 16:05:51 +0000970 // Loop over the arguments, printing them...
Chris Lattnerfee714f2001-09-07 16:36:04 +0000971
Reid Spencer8c4914c2006-12-31 05:24:50 +0000972 unsigned Idx = 1;
Chris Lattner82738fe2007-04-18 00:57:22 +0000973 if (!F->isDeclaration()) {
974 // If this isn't a declaration, print the argument names as well.
975 for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
976 I != E; ++I) {
977 // Insert commas as we go... the first arg doesn't get a comma
978 if (I != F->arg_begin()) Out << ", ";
979 printArgument(I, (Attrs ? Attrs->getParamAttrs(Idx)
980 : uint16_t(ParamAttr::None)));
981 Idx++;
982 }
983 } else {
984 // Otherwise, print the types from the function type.
985 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
986 // Insert commas as we go... the first arg doesn't get a comma
987 if (i) Out << ", ";
988
989 // Output type...
990 printType(FT->getParamType(i));
991
992 unsigned ArgAttrs = ParamAttr::None;
993 if (Attrs) ArgAttrs = Attrs->getParamAttrs(i+1);
994 if (ArgAttrs != ParamAttr::None)
995 Out << ' ' << ParamAttrsList::getParamAttrsText(ArgAttrs);
996 }
Reid Spencer8c4914c2006-12-31 05:24:50 +0000997 }
Chris Lattnerfee714f2001-09-07 16:36:04 +0000998
999 // Finish printing arguments...
Chris Lattner113f4f42002-06-25 16:13:24 +00001000 if (FT->isVarArg()) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001001 if (FT->getNumParams()) Out << ", ";
1002 Out << "..."; // Output varargs portion of signature!
Chris Lattnerfee714f2001-09-07 16:36:04 +00001003 }
Misha Brukmana6619a92004-06-21 21:53:56 +00001004 Out << ')';
Reid Spencera472f662007-04-11 02:44:20 +00001005 if (Attrs && Attrs->getParamAttrs(0) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001006 Out << ' ' << Attrs->getParamAttrsTextByIndex(0);
Chris Lattner4b96c542005-11-12 00:10:19 +00001007 if (F->hasSection())
1008 Out << " section \"" << F->getSection() << '"';
Chris Lattnerf8a974d2005-11-06 06:48:53 +00001009 if (F->getAlignment())
1010 Out << " align " << F->getAlignment();
Chris Lattner4b96c542005-11-12 00:10:19 +00001011
Reid Spencer5301e7c2007-01-30 20:08:39 +00001012 if (F->isDeclaration()) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001013 Out << "\n";
Chris Lattnerb2f02e52002-05-06 03:00:40 +00001014 } else {
Misha Brukmana6619a92004-06-21 21:53:56 +00001015 Out << " {";
Misha Brukmanb1c93172005-04-21 23:48:37 +00001016
Chris Lattner6915f8f2002-04-07 22:49:37 +00001017 // Output all of its basic blocks... for the function
Chris Lattner113f4f42002-06-25 16:13:24 +00001018 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
1019 printBasicBlock(I);
Chris Lattnerfee714f2001-09-07 16:36:04 +00001020
Misha Brukmana6619a92004-06-21 21:53:56 +00001021 Out << "}\n";
Chris Lattnerfee714f2001-09-07 16:36:04 +00001022 }
1023
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001024 Machine.purgeFunction();
Chris Lattner2f7c9632001-06-06 20:29:01 +00001025}
1026
Misha Brukmanc566ca362004-03-02 00:22:19 +00001027/// printArgument - This member is called for every argument that is passed into
1028/// the function. Simply print it out
1029///
Reid Spencer1517de32007-04-09 06:10:42 +00001030void AssemblyWriter::printArgument(const Argument *Arg, uint16_t Attrs) {
Chris Lattner2f7c9632001-06-06 20:29:01 +00001031 // Output type...
Chris Lattner7bfee412001-10-29 16:05:51 +00001032 printType(Arg->getType());
Misha Brukmanb1c93172005-04-21 23:48:37 +00001033
Reid Spencera472f662007-04-11 02:44:20 +00001034 if (Attrs != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001035 Out << ' ' << ParamAttrsList::getParamAttrsText(Attrs);
Reid Spencer8c4914c2006-12-31 05:24:50 +00001036
Chris Lattner2f7c9632001-06-06 20:29:01 +00001037 // Output name, if available...
1038 if (Arg->hasName())
Reid Spencer788e3172007-01-26 08:02:52 +00001039 Out << ' ' << getLLVMName(Arg->getName(), LocalPrefix);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001040}
1041
Misha Brukmanc566ca362004-03-02 00:22:19 +00001042/// printBasicBlock - This member is called for each basic block in a method.
1043///
Chris Lattner7bfee412001-10-29 16:05:51 +00001044void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
Chris Lattner2f7c9632001-06-06 20:29:01 +00001045 if (BB->hasName()) { // Print out the label if it exists...
Reid Spencer788e3172007-01-26 08:02:52 +00001046 Out << "\n" << getLLVMName(BB->getName(), LabelPrefix) << ':';
Chris Lattner408dbdb2002-05-14 16:02:05 +00001047 } else if (!BB->use_empty()) { // Don't print block # of no uses...
Misha Brukmana6619a92004-06-21 21:53:56 +00001048 Out << "\n; <label>:";
Chris Lattner5e043322007-01-11 03:54:27 +00001049 int Slot = Machine.getLocalSlot(BB);
Chris Lattner757ee0b2004-06-09 19:41:19 +00001050 if (Slot != -1)
Misha Brukmana6619a92004-06-21 21:53:56 +00001051 Out << Slot;
Chris Lattner757ee0b2004-06-09 19:41:19 +00001052 else
Misha Brukmana6619a92004-06-21 21:53:56 +00001053 Out << "<badref>";
Chris Lattner58185f22002-10-02 19:38:55 +00001054 }
Chris Lattner2447ef52003-11-20 00:09:43 +00001055
1056 if (BB->getParent() == 0)
Misha Brukmana6619a92004-06-21 21:53:56 +00001057 Out << "\t\t; Error: Block without parent!";
Chris Lattner2447ef52003-11-20 00:09:43 +00001058 else {
Dan Gohmandcb291f2007-03-22 16:38:57 +00001059 if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
Chris Lattner2447ef52003-11-20 00:09:43 +00001060 // Output predecessors for the block...
Misha Brukmana6619a92004-06-21 21:53:56 +00001061 Out << "\t\t;";
Chris Lattner2447ef52003-11-20 00:09:43 +00001062 pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
Misha Brukmanb1c93172005-04-21 23:48:37 +00001063
Chris Lattner2447ef52003-11-20 00:09:43 +00001064 if (PI == PE) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001065 Out << " No predecessors!";
Chris Lattner2447ef52003-11-20 00:09:43 +00001066 } else {
Misha Brukmana6619a92004-06-21 21:53:56 +00001067 Out << " preds =";
Chris Lattner78e2e8b2006-12-06 06:24:27 +00001068 writeOperand(*PI, false);
Chris Lattner2447ef52003-11-20 00:09:43 +00001069 for (++PI; PI != PE; ++PI) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001070 Out << ',';
Chris Lattner78e2e8b2006-12-06 06:24:27 +00001071 writeOperand(*PI, false);
Chris Lattner2447ef52003-11-20 00:09:43 +00001072 }
Chris Lattner00211f12003-11-16 22:59:57 +00001073 }
Chris Lattner58185f22002-10-02 19:38:55 +00001074 }
Chris Lattner2f7c9632001-06-06 20:29:01 +00001075 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00001076
Misha Brukmana6619a92004-06-21 21:53:56 +00001077 Out << "\n";
Chris Lattner2f7c9632001-06-06 20:29:01 +00001078
Misha Brukmana6619a92004-06-21 21:53:56 +00001079 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
Chris Lattner8339f7d2003-10-30 23:41:03 +00001080
Chris Lattnerfee714f2001-09-07 16:36:04 +00001081 // Output all of the instructions in the basic block...
Chris Lattner113f4f42002-06-25 16:13:24 +00001082 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
1083 printInstruction(*I);
Chris Lattner96cdd272004-03-08 18:51:45 +00001084
Misha Brukmana6619a92004-06-21 21:53:56 +00001085 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001086}
1087
Chris Lattner862e3382001-10-13 06:42:36 +00001088
Misha Brukmanc566ca362004-03-02 00:22:19 +00001089/// printInfoComment - Print a little comment after the instruction indicating
1090/// which slot it occupies.
1091///
Chris Lattner113f4f42002-06-25 16:13:24 +00001092void AssemblyWriter::printInfoComment(const Value &V) {
1093 if (V.getType() != Type::VoidTy) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001094 Out << "\t\t; <";
Misha Brukman21bbdb92004-06-04 21:11:51 +00001095 printType(V.getType()) << '>';
Chris Lattner862e3382001-10-13 06:42:36 +00001096
Chris Lattner113f4f42002-06-25 16:13:24 +00001097 if (!V.hasName()) {
Chris Lattner5e043322007-01-11 03:54:27 +00001098 int SlotNum;
1099 if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V))
1100 SlotNum = Machine.getGlobalSlot(GV);
1101 else
1102 SlotNum = Machine.getLocalSlot(&V);
Chris Lattner757ee0b2004-06-09 19:41:19 +00001103 if (SlotNum == -1)
Misha Brukmana6619a92004-06-21 21:53:56 +00001104 Out << ":<badref>";
Reid Spencer8beac692004-06-09 15:26:53 +00001105 else
Misha Brukmana6619a92004-06-21 21:53:56 +00001106 Out << ':' << SlotNum; // Print out the def slot taken.
Chris Lattner862e3382001-10-13 06:42:36 +00001107 }
Chris Lattnerb6c21db2005-02-01 01:24:01 +00001108 Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses
Chris Lattner862e3382001-10-13 06:42:36 +00001109 }
1110}
1111
Reid Spencere7141c82006-08-28 01:02:49 +00001112// This member is called for each Instruction in a function..
Chris Lattner113f4f42002-06-25 16:13:24 +00001113void AssemblyWriter::printInstruction(const Instruction &I) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001114 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
Chris Lattner8339f7d2003-10-30 23:41:03 +00001115
Misha Brukmana6619a92004-06-21 21:53:56 +00001116 Out << "\t";
Chris Lattner2f7c9632001-06-06 20:29:01 +00001117
1118 // Print out name if it exists...
Chris Lattner113f4f42002-06-25 16:13:24 +00001119 if (I.hasName())
Reid Spencer788e3172007-01-26 08:02:52 +00001120 Out << getLLVMName(I.getName(), LocalPrefix) << " = ";
Chris Lattner2f7c9632001-06-06 20:29:01 +00001121
Chris Lattner06038452005-05-06 05:51:46 +00001122 // If this is a volatile load or store, print out the volatile marker.
Chris Lattner504f9242003-09-08 17:45:59 +00001123 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
Chris Lattner06038452005-05-06 05:51:46 +00001124 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001125 Out << "volatile ";
Chris Lattner06038452005-05-06 05:51:46 +00001126 } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) {
1127 // If this is a call, check if it's a tail call.
1128 Out << "tail ";
1129 }
Chris Lattner504f9242003-09-08 17:45:59 +00001130
Chris Lattner2f7c9632001-06-06 20:29:01 +00001131 // Print out the opcode...
Misha Brukmana6619a92004-06-21 21:53:56 +00001132 Out << I.getOpcodeName();
Chris Lattner2f7c9632001-06-06 20:29:01 +00001133
Reid Spencer45e52392006-12-03 06:27:29 +00001134 // Print out the compare instruction predicates
1135 if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) {
Reid Spencer812a1be2006-12-04 05:19:18 +00001136 Out << " " << getPredicateText(FCI->getPredicate());
Reid Spencer45e52392006-12-03 06:27:29 +00001137 } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) {
Reid Spencer812a1be2006-12-04 05:19:18 +00001138 Out << " " << getPredicateText(ICI->getPredicate());
Reid Spencer45e52392006-12-03 06:27:29 +00001139 }
1140
Chris Lattner2f7c9632001-06-06 20:29:01 +00001141 // Print out the type of the operands...
Chris Lattner113f4f42002-06-25 16:13:24 +00001142 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
Chris Lattner2f7c9632001-06-06 20:29:01 +00001143
1144 // Special case conditional branches to swizzle the condition out to the front
Chris Lattner113f4f42002-06-25 16:13:24 +00001145 if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
1146 writeOperand(I.getOperand(2), true);
Misha Brukmana6619a92004-06-21 21:53:56 +00001147 Out << ',';
Chris Lattner2f7c9632001-06-06 20:29:01 +00001148 writeOperand(Operand, true);
Misha Brukmana6619a92004-06-21 21:53:56 +00001149 Out << ',';
Chris Lattner113f4f42002-06-25 16:13:24 +00001150 writeOperand(I.getOperand(1), true);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001151
Chris Lattner8d48df22002-04-13 18:34:38 +00001152 } else if (isa<SwitchInst>(I)) {
Chris Lattner2f7c9632001-06-06 20:29:01 +00001153 // Special case switch statement to get formatting nice and correct...
Misha Brukmana6619a92004-06-21 21:53:56 +00001154 writeOperand(Operand , true); Out << ',';
1155 writeOperand(I.getOperand(1), true); Out << " [";
Chris Lattner2f7c9632001-06-06 20:29:01 +00001156
Chris Lattner113f4f42002-06-25 16:13:24 +00001157 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001158 Out << "\n\t\t";
1159 writeOperand(I.getOperand(op ), true); Out << ',';
Chris Lattner113f4f42002-06-25 16:13:24 +00001160 writeOperand(I.getOperand(op+1), true);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001161 }
Misha Brukmana6619a92004-06-21 21:53:56 +00001162 Out << "\n\t]";
Chris Lattnerda558102001-10-02 03:41:24 +00001163 } else if (isa<PHINode>(I)) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001164 Out << ' ';
Chris Lattner113f4f42002-06-25 16:13:24 +00001165 printType(I.getType());
Misha Brukmana6619a92004-06-21 21:53:56 +00001166 Out << ' ';
Chris Lattner2f7c9632001-06-06 20:29:01 +00001167
Chris Lattner113f4f42002-06-25 16:13:24 +00001168 for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001169 if (op) Out << ", ";
Misha Brukmanb1c93172005-04-21 23:48:37 +00001170 Out << '[';
Misha Brukmana6619a92004-06-21 21:53:56 +00001171 writeOperand(I.getOperand(op ), false); Out << ',';
1172 writeOperand(I.getOperand(op+1), false); Out << " ]";
Chris Lattner931ef3b2001-06-11 15:04:20 +00001173 }
Chris Lattner862e3382001-10-13 06:42:36 +00001174 } else if (isa<ReturnInst>(I) && !Operand) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001175 Out << " void";
Chris Lattnerf7b6d312005-05-06 20:26:43 +00001176 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
1177 // Print the calling convention being used.
1178 switch (CI->getCallingConv()) {
1179 case CallingConv::C: break; // default
Chris Lattner29d20852006-05-19 21:58:52 +00001180 case CallingConv::Fast: Out << " fastcc"; break;
1181 case CallingConv::Cold: Out << " coldcc"; break;
Anton Korobeynikov3c5b3df2006-09-20 22:03:51 +00001182 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
1183 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
Chris Lattnerf7b6d312005-05-06 20:26:43 +00001184 default: Out << " cc" << CI->getCallingConv(); break;
1185 }
1186
Reid Spencer1517de32007-04-09 06:10:42 +00001187 const PointerType *PTy = cast<PointerType>(Operand->getType());
1188 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
1189 const Type *RetTy = FTy->getReturnType();
1190 const ParamAttrsList *PAL = FTy->getParamAttrs();
Chris Lattner2f2d9472001-11-06 21:28:12 +00001191
Chris Lattner463d6a52003-08-05 15:34:45 +00001192 // If possible, print out the short form of the call instruction. We can
Chris Lattner6915f8f2002-04-07 22:49:37 +00001193 // only do this if the first argument is a pointer to a nonvararg function,
Chris Lattner463d6a52003-08-05 15:34:45 +00001194 // and if the return type is not a pointer to a function.
Chris Lattner2f2d9472001-11-06 21:28:12 +00001195 //
Chris Lattner463d6a52003-08-05 15:34:45 +00001196 if (!FTy->isVarArg() &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00001197 (!isa<PointerType>(RetTy) ||
Chris Lattnerd9a36a62002-07-25 20:58:51 +00001198 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001199 Out << ' '; printType(RetTy);
Chris Lattner2f2d9472001-11-06 21:28:12 +00001200 writeOperand(Operand, false);
1201 } else {
1202 writeOperand(Operand, true);
1203 }
Misha Brukmana6619a92004-06-21 21:53:56 +00001204 Out << '(';
Reid Spencer8c4914c2006-12-31 05:24:50 +00001205 for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) {
1206 if (op > 1)
1207 Out << ',';
Chris Lattner113f4f42002-06-25 16:13:24 +00001208 writeOperand(I.getOperand(op), true);
Reid Spencera472f662007-04-11 02:44:20 +00001209 if (PAL && PAL->getParamAttrs(op) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001210 Out << " " << PAL->getParamAttrsTextByIndex(op);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001211 }
Misha Brukmana6619a92004-06-21 21:53:56 +00001212 Out << " )";
Reid Spencera472f662007-04-11 02:44:20 +00001213 if (PAL && PAL->getParamAttrs(0) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001214 Out << ' ' << PAL->getParamAttrsTextByIndex(0);
Chris Lattner113f4f42002-06-25 16:13:24 +00001215 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
Reid Spencer1517de32007-04-09 06:10:42 +00001216 const PointerType *PTy = cast<PointerType>(Operand->getType());
1217 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
1218 const Type *RetTy = FTy->getReturnType();
1219 const ParamAttrsList *PAL = FTy->getParamAttrs();
Chris Lattner463d6a52003-08-05 15:34:45 +00001220
Chris Lattnerf7b6d312005-05-06 20:26:43 +00001221 // Print the calling convention being used.
1222 switch (II->getCallingConv()) {
1223 case CallingConv::C: break; // default
Chris Lattner29d20852006-05-19 21:58:52 +00001224 case CallingConv::Fast: Out << " fastcc"; break;
1225 case CallingConv::Cold: Out << " coldcc"; break;
Anton Korobeynikov3c5b3df2006-09-20 22:03:51 +00001226 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break;
1227 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
Chris Lattnerf7b6d312005-05-06 20:26:43 +00001228 default: Out << " cc" << II->getCallingConv(); break;
1229 }
1230
Chris Lattner463d6a52003-08-05 15:34:45 +00001231 // If possible, print out the short form of the invoke instruction. We can
1232 // only do this if the first argument is a pointer to a nonvararg function,
1233 // and if the return type is not a pointer to a function.
1234 //
1235 if (!FTy->isVarArg() &&
Misha Brukmanb1c93172005-04-21 23:48:37 +00001236 (!isa<PointerType>(RetTy) ||
Chris Lattner463d6a52003-08-05 15:34:45 +00001237 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001238 Out << ' '; printType(RetTy);
Chris Lattner463d6a52003-08-05 15:34:45 +00001239 writeOperand(Operand, false);
1240 } else {
1241 writeOperand(Operand, true);
1242 }
1243
Misha Brukmana6619a92004-06-21 21:53:56 +00001244 Out << '(';
Reid Spencer8c4914c2006-12-31 05:24:50 +00001245 for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
1246 if (op > 3)
1247 Out << ',';
Chris Lattner113f4f42002-06-25 16:13:24 +00001248 writeOperand(I.getOperand(op), true);
Reid Spencera472f662007-04-11 02:44:20 +00001249 if (PAL && PAL->getParamAttrs(op-2) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001250 Out << " " << PAL->getParamAttrsTextByIndex(op-2);
Chris Lattner862e3382001-10-13 06:42:36 +00001251 }
1252
Reid Spencer136a91c2007-01-05 17:06:19 +00001253 Out << " )";
Reid Spencera472f662007-04-11 02:44:20 +00001254 if (PAL && PAL->getParamAttrs(0) != ParamAttr::None)
Reid Spencer1517de32007-04-09 06:10:42 +00001255 Out << " " << PAL->getParamAttrsTextByIndex(0);
Reid Spencer136a91c2007-01-05 17:06:19 +00001256 Out << "\n\t\t\tto";
Chris Lattner862e3382001-10-13 06:42:36 +00001257 writeOperand(II->getNormalDest(), true);
Misha Brukmana6619a92004-06-21 21:53:56 +00001258 Out << " unwind";
Chris Lattnerfae8ab32004-02-08 21:44:31 +00001259 writeOperand(II->getUnwindDest(), true);
Chris Lattner862e3382001-10-13 06:42:36 +00001260
Chris Lattner113f4f42002-06-25 16:13:24 +00001261 } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001262 Out << ' ';
Chris Lattner8d48df22002-04-13 18:34:38 +00001263 printType(AI->getType()->getElementType());
1264 if (AI->isArrayAllocation()) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001265 Out << ',';
Chris Lattner8d48df22002-04-13 18:34:38 +00001266 writeOperand(AI->getArraySize(), true);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001267 }
Nate Begeman848622f2005-11-05 09:21:28 +00001268 if (AI->getAlignment()) {
Chris Lattner7aeee3a2005-11-05 21:20:34 +00001269 Out << ", align " << AI->getAlignment();
Nate Begeman848622f2005-11-05 09:21:28 +00001270 }
Chris Lattner862e3382001-10-13 06:42:36 +00001271 } else if (isa<CastInst>(I)) {
Chris Lattnerc96e96b2003-11-17 01:17:04 +00001272 if (Operand) writeOperand(Operand, true); // Work with broken code
Misha Brukmana6619a92004-06-21 21:53:56 +00001273 Out << " to ";
Chris Lattner113f4f42002-06-25 16:13:24 +00001274 printType(I.getType());
Chris Lattner5b337482003-10-18 05:57:43 +00001275 } else if (isa<VAArgInst>(I)) {
Chris Lattnerc96e96b2003-11-17 01:17:04 +00001276 if (Operand) writeOperand(Operand, true); // Work with broken code
Misha Brukmana6619a92004-06-21 21:53:56 +00001277 Out << ", ";
Chris Lattnerf70da102003-05-08 02:44:12 +00001278 printType(I.getType());
Chris Lattner2f7c9632001-06-06 20:29:01 +00001279 } else if (Operand) { // Print the normal way...
1280
Misha Brukmanb1c93172005-04-21 23:48:37 +00001281 // PrintAllTypes - Instructions who have operands of all the same type
Chris Lattner2f7c9632001-06-06 20:29:01 +00001282 // omit the type from all but the first operand. If the instruction has
1283 // different type operands (for example br), then they are all printed.
1284 bool PrintAllTypes = false;
1285 const Type *TheType = Operand->getType();
Chris Lattner2f7c9632001-06-06 20:29:01 +00001286
Reid Spencer0cdd04f2007-02-02 13:54:55 +00001287 // Select, Store and ShuffleVector always print all types.
Reid Spencer2341c222007-02-02 02:16:23 +00001288 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)) {
Chris Lattnerdeccfaf2003-04-16 20:20:02 +00001289 PrintAllTypes = true;
1290 } else {
1291 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
1292 Operand = I.getOperand(i);
1293 if (Operand->getType() != TheType) {
1294 PrintAllTypes = true; // We have differing types! Print them all!
1295 break;
1296 }
Chris Lattner2f7c9632001-06-06 20:29:01 +00001297 }
1298 }
Misha Brukmanb1c93172005-04-21 23:48:37 +00001299
Chris Lattner7bfee412001-10-29 16:05:51 +00001300 if (!PrintAllTypes) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001301 Out << ' ';
Chris Lattnerdeccfaf2003-04-16 20:20:02 +00001302 printType(TheType);
Chris Lattner7bfee412001-10-29 16:05:51 +00001303 }
Chris Lattner2f7c9632001-06-06 20:29:01 +00001304
Chris Lattner113f4f42002-06-25 16:13:24 +00001305 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
Misha Brukmana6619a92004-06-21 21:53:56 +00001306 if (i) Out << ',';
Chris Lattner113f4f42002-06-25 16:13:24 +00001307 writeOperand(I.getOperand(i), PrintAllTypes);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001308 }
1309 }
1310
Chris Lattner862e3382001-10-13 06:42:36 +00001311 printInfoComment(I);
Misha Brukmana6619a92004-06-21 21:53:56 +00001312 Out << "\n";
Chris Lattner2f7c9632001-06-06 20:29:01 +00001313}
1314
1315
1316//===----------------------------------------------------------------------===//
1317// External Interface declarations
1318//===----------------------------------------------------------------------===//
1319
Chris Lattner8339f7d2003-10-30 23:41:03 +00001320void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001321 SlotMachine SlotTable(this);
Chris Lattner8339f7d2003-10-30 23:41:03 +00001322 AssemblyWriter W(o, SlotTable, this, AAW);
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001323 W.write(this);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001324}
1325
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001326void GlobalVariable::print(std::ostream &o) const {
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001327 SlotMachine SlotTable(getParent());
Chris Lattner8339f7d2003-10-30 23:41:03 +00001328 AssemblyWriter W(o, SlotTable, getParent(), 0);
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001329 W.write(this);
Chris Lattneradfe0d12001-09-10 20:08:19 +00001330}
1331
Chris Lattner8339f7d2003-10-30 23:41:03 +00001332void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001333 SlotMachine SlotTable(getParent());
Chris Lattner8339f7d2003-10-30 23:41:03 +00001334 AssemblyWriter W(o, SlotTable, getParent(), AAW);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001335
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001336 W.write(this);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001337}
1338
Chris Lattnereef2fe72006-01-24 04:13:11 +00001339void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
Chris Lattner78e2e8b2006-12-06 06:24:27 +00001340 WriteAsOperand(o, this, true, 0);
Chris Lattnereef2fe72006-01-24 04:13:11 +00001341}
1342
Chris Lattner8339f7d2003-10-30 23:41:03 +00001343void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001344 SlotMachine SlotTable(getParent());
Misha Brukmanb1c93172005-04-21 23:48:37 +00001345 AssemblyWriter W(o, SlotTable,
Chris Lattner8339f7d2003-10-30 23:41:03 +00001346 getParent() ? getParent()->getParent() : 0, AAW);
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001347 W.write(this);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001348}
1349
Chris Lattner8339f7d2003-10-30 23:41:03 +00001350void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001351 const Function *F = getParent() ? getParent()->getParent() : 0;
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001352 SlotMachine SlotTable(F);
Chris Lattner8339f7d2003-10-30 23:41:03 +00001353 AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001354
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001355 W.write(this);
Chris Lattner2f7c9632001-06-06 20:29:01 +00001356}
Chris Lattner7db79582001-11-07 04:21:57 +00001357
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001358void Constant::print(std::ostream &o) const {
1359 if (this == 0) { o << "<null> constant value\n"; return; }
Chris Lattner7d734802002-09-10 15:53:49 +00001360
Misha Brukman21bbdb92004-06-04 21:11:51 +00001361 o << ' ' << getType()->getDescription() << ' ';
Evan Cheng5b19a802006-03-01 22:17:00 +00001362
1363 std::map<const Type *, std::string> TypeTable;
Chris Lattner78e2e8b2006-12-06 06:24:27 +00001364 WriteConstantInt(o, this, TypeTable, 0);
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001365}
1366
Misha Brukmanb1c93172005-04-21 23:48:37 +00001367void Type::print(std::ostream &o) const {
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001368 if (this == 0)
1369 o << "<null Type>";
1370 else
1371 o << getDescription();
1372}
1373
Chris Lattner2e9fa6d2002-04-09 19:48:49 +00001374void Argument::print(std::ostream &o) const {
Chris Lattner78e2e8b2006-12-06 06:24:27 +00001375 WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0);
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001376}
1377
Reid Spencer52641832004-05-25 18:14:38 +00001378// Value::dump - allow easy printing of Values from the debugger.
1379// Located here because so much of the needed functionality is here.
Bill Wendling22e978a2006-12-07 20:04:42 +00001380void Value::dump() const { print(*cerr.stream()); cerr << '\n'; }
Reid Spencer52641832004-05-25 18:14:38 +00001381
1382// Type::dump - allow easy printing of Values from the debugger.
1383// Located here because so much of the needed functionality is here.
Bill Wendling22e978a2006-12-07 20:04:42 +00001384void Type::dump() const { print(*cerr.stream()); cerr << '\n'; }
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001385
Reid Spencer4388f0b2007-04-22 05:46:44 +00001386void
1387ParamAttrsList::dump() const {
1388 cerr << "PAL[ ";
1389 for (unsigned i = 0; i < attrs.size(); ++i) {
1390 uint16_t index = getParamIndex(i);
1391 uint16_t attrs = getParamAttrs(index);
1392 cerr << "{" << index << "," << attrs << "} ";
1393 }
1394 cerr << "]\n";
1395}
1396
Chris Lattnerc0b4c7b2002-04-08 22:03:40 +00001397//===----------------------------------------------------------------------===//
Chris Lattnerfc9f1c92006-12-06 06:40:49 +00001398// SlotMachine Implementation
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001399//===----------------------------------------------------------------------===//
1400
1401#if 0
Bill Wendlingf3baad32006-12-07 01:30:32 +00001402#define SC_DEBUG(X) cerr << X
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001403#else
1404#define SC_DEBUG(X)
1405#endif
1406
1407// Module level constructor. Causes the contents of the Module (sans functions)
1408// to be added to the slot table.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001409SlotMachine::SlotMachine(const Module *M)
Reid Spencer56010e42004-05-26 21:56:09 +00001410 : TheModule(M) ///< Saved for lazy initialization.
1411 , TheFunction(0)
Reid Spencerb0ac8c42004-08-16 07:46:33 +00001412 , FunctionProcessed(false)
Reid Spencer50816782007-03-19 18:32:53 +00001413 , mMap(), mNext(0), fMap(), fNext(0)
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001414{
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001415}
1416
1417// Function level constructor. Causes the contents of the Module and the one
1418// function provided to be added to the slot table.
Chris Lattner23e829a2006-12-06 05:12:21 +00001419SlotMachine::SlotMachine(const Function *F)
1420 : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization
Reid Spencer56010e42004-05-26 21:56:09 +00001421 , TheFunction(F) ///< Saved for lazy initialization
Reid Spencerb0ac8c42004-08-16 07:46:33 +00001422 , FunctionProcessed(false)
Reid Spencer50816782007-03-19 18:32:53 +00001423 , mMap(), mNext(0), fMap(), fNext(0)
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001424{
Reid Spencer56010e42004-05-26 21:56:09 +00001425}
1426
Chris Lattner5e043322007-01-11 03:54:27 +00001427inline void SlotMachine::initialize() {
Chris Lattner23e829a2006-12-06 05:12:21 +00001428 if (TheModule) {
Misha Brukmanb1c93172005-04-21 23:48:37 +00001429 processModule();
Reid Spencer56010e42004-05-26 21:56:09 +00001430 TheModule = 0; ///< Prevent re-processing next time we're called.
1431 }
Chris Lattner193de902006-12-06 05:27:40 +00001432 if (TheFunction && !FunctionProcessed)
Misha Brukmanb1c93172005-04-21 23:48:37 +00001433 processFunction();
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001434}
1435
1436// Iterate through all the global variables, functions, and global
Misha Brukmanb1c93172005-04-21 23:48:37 +00001437// variable initializers and create slots for them.
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001438void SlotMachine::processModule() {
1439 SC_DEBUG("begin processModule!\n");
1440
Chris Lattner0dda8612006-12-06 06:15:43 +00001441 // Add all of the unnamed global variables to the value table.
Chris Lattner54932b02006-12-06 04:41:52 +00001442 for (Module::const_global_iterator I = TheModule->global_begin(),
1443 E = TheModule->global_end(); I != E; ++I)
Chris Lattner0dda8612006-12-06 06:15:43 +00001444 if (!I->hasName())
Chris Lattnerea862a32007-01-09 07:55:49 +00001445 CreateModuleSlot(I);
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001446
Chris Lattner0dda8612006-12-06 06:15:43 +00001447 // Add all the unnamed functions to the table.
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001448 for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
1449 I != E; ++I)
Chris Lattner0dda8612006-12-06 06:15:43 +00001450 if (!I->hasName())
Chris Lattnerea862a32007-01-09 07:55:49 +00001451 CreateModuleSlot(I);
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001452
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001453 SC_DEBUG("end processModule!\n");
1454}
1455
1456
Reid Spencer56010e42004-05-26 21:56:09 +00001457// Process the arguments, basic blocks, and instructions of a function.
1458void SlotMachine::processFunction() {
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001459 SC_DEBUG("begin processFunction!\n");
Reid Spencer50816782007-03-19 18:32:53 +00001460 fNext = 0;
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001461
Chris Lattner0dda8612006-12-06 06:15:43 +00001462 // Add all the function arguments with no names.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001463 for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
Chris Lattner531f9e92005-03-15 04:54:21 +00001464 AE = TheFunction->arg_end(); AI != AE; ++AI)
Chris Lattner0dda8612006-12-06 06:15:43 +00001465 if (!AI->hasName())
Chris Lattnerea862a32007-01-09 07:55:49 +00001466 CreateFunctionSlot(AI);
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001467
1468 SC_DEBUG("Inserting Instructions:\n");
1469
Chris Lattner0dda8612006-12-06 06:15:43 +00001470 // Add all of the basic blocks and instructions with no names.
Misha Brukmanb1c93172005-04-21 23:48:37 +00001471 for (Function::const_iterator BB = TheFunction->begin(),
Reid Spencer56010e42004-05-26 21:56:09 +00001472 E = TheFunction->end(); BB != E; ++BB) {
Chris Lattner0dda8612006-12-06 06:15:43 +00001473 if (!BB->hasName())
Chris Lattnerea862a32007-01-09 07:55:49 +00001474 CreateFunctionSlot(BB);
Chris Lattner0dda8612006-12-06 06:15:43 +00001475 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
1476 if (I->getType() != Type::VoidTy && !I->hasName())
Chris Lattnerea862a32007-01-09 07:55:49 +00001477 CreateFunctionSlot(I);
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001478 }
1479
Reid Spencerb0ac8c42004-08-16 07:46:33 +00001480 FunctionProcessed = true;
1481
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001482 SC_DEBUG("end processFunction!\n");
1483}
1484
Chris Lattner193de902006-12-06 05:27:40 +00001485/// Clean up after incorporating a function. This is the only way to get out of
Chris Lattner5e043322007-01-11 03:54:27 +00001486/// the function incorporation state that affects get*Slot/Create*Slot. Function
Chris Lattner89e774e2007-01-09 07:46:21 +00001487/// incorporation state is indicated by TheFunction != 0.
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001488void SlotMachine::purgeFunction() {
1489 SC_DEBUG("begin purgeFunction!\n");
1490 fMap.clear(); // Simply discard the function level map
Reid Spencer56010e42004-05-26 21:56:09 +00001491 TheFunction = 0;
Reid Spencerb0ac8c42004-08-16 07:46:33 +00001492 FunctionProcessed = false;
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001493 SC_DEBUG("end purgeFunction!\n");
1494}
1495
Chris Lattner5e043322007-01-11 03:54:27 +00001496/// getGlobalSlot - Get the slot number of a global value.
1497int SlotMachine::getGlobalSlot(const GlobalValue *V) {
1498 // Check for uninitialized state and do lazy initialization.
1499 initialize();
1500
1501 // Find the type plane in the module map
Reid Spencer50816782007-03-19 18:32:53 +00001502 ValueMap::const_iterator MI = mMap.find(V);
Chris Lattner5e043322007-01-11 03:54:27 +00001503 if (MI == mMap.end()) return -1;
Reid Spencer50816782007-03-19 18:32:53 +00001504
1505 return MI->second;
Chris Lattner5e043322007-01-11 03:54:27 +00001506}
Reid Spencer56010e42004-05-26 21:56:09 +00001507
Chris Lattner5e043322007-01-11 03:54:27 +00001508
1509/// getLocalSlot - Get the slot number for a value that is local to a function.
1510int SlotMachine::getLocalSlot(const Value *V) {
1511 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
1512
1513 // Check for uninitialized state and do lazy initialization.
1514 initialize();
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001515
Reid Spencer50816782007-03-19 18:32:53 +00001516 ValueMap::const_iterator FI = fMap.find(V);
Chris Lattner5e043322007-01-11 03:54:27 +00001517 if (FI == fMap.end()) return -1;
1518
Reid Spencer50816782007-03-19 18:32:53 +00001519 return FI->second;
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001520}
1521
Reid Spencer58d30f22004-07-04 11:50:43 +00001522
Chris Lattnerea862a32007-01-09 07:55:49 +00001523/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
1524void SlotMachine::CreateModuleSlot(const GlobalValue *V) {
Chris Lattner04398e82007-01-09 08:04:59 +00001525 assert(V && "Can't insert a null Value into SlotMachine!");
Reid Spencer50816782007-03-19 18:32:53 +00001526 assert(V->getType() != Type::VoidTy && "Doesn't need a slot!");
1527 assert(!V->hasName() && "Doesn't need a slot!");
Chris Lattner04398e82007-01-09 08:04:59 +00001528
Reid Spencer50816782007-03-19 18:32:53 +00001529 unsigned DestSlot = mNext++;
1530 mMap[V] = DestSlot;
Chris Lattner04398e82007-01-09 08:04:59 +00001531
Reid Spencer50816782007-03-19 18:32:53 +00001532 SC_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
Chris Lattner04398e82007-01-09 08:04:59 +00001533 DestSlot << " [");
1534 // G = Global, F = Function, o = other
1535 SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 'F') << "]\n");
Reid Spencer16f2f7f2004-05-26 07:18:52 +00001536}
1537
1538
Chris Lattnerea862a32007-01-09 07:55:49 +00001539/// CreateSlot - Create a new slot for the specified value if it has no name.
1540void SlotMachine::CreateFunctionSlot(const Value *V) {
1541 const Type *VTy = V->getType();
1542 assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!");
Chris Lattner04398e82007-01-09 08:04:59 +00001543
Reid Spencer50816782007-03-19 18:32:53 +00001544 unsigned DestSlot = fNext++;
1545 fMap[V] = DestSlot;
Chris Lattner04398e82007-01-09 08:04:59 +00001546
Chris Lattnerf8090cb2006-12-06 05:55:41 +00001547 // G = Global, F = Function, o = other
Chris Lattner04398e82007-01-09 08:04:59 +00001548 SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" <<
1549 DestSlot << " [o]\n");
1550}