1 //===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This library implements the functionality defined in llvm/Assembly/Writer.h
12 // Note that these routines must be extremely tolerant of various errors in the
13 // LLVM code, because it can be used for debugging transformations.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/Assembly/CachedWriter.h"
18 #include "llvm/Assembly/Writer.h"
19 #include "llvm/Assembly/PrintModulePass.h"
20 #include "llvm/Assembly/AsmAnnotationWriter.h"
21 #include "llvm/SlotCalculator.h"
22 #include "llvm/DerivedTypes.h"
23 #include "llvm/Instruction.h"
24 #include "llvm/Module.h"
25 #include "llvm/Constants.h"
26 #include "llvm/iMemory.h"
27 #include "llvm/iTerminators.h"
28 #include "llvm/iPHINode.h"
29 #include "llvm/iOther.h"
30 #include "llvm/SymbolTable.h"
31 #include "llvm/Support/CFG.h"
32 #include "Support/StringExtras.h"
33 #include "Support/STLExtras.h"
38 static RegisterPass<PrintModulePass>
39 X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
40 static RegisterPass<PrintFunctionPass>
41 Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization);
43 static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
45 std::map<const Type *, std::string> &TypeTable,
46 SlotCalculator *Table);
48 static const Module *getModuleFromVal(const Value *V) {
49 if (const Argument *MA = dyn_cast<Argument>(V))
50 return MA->getParent() ? MA->getParent()->getParent() : 0;
51 else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
52 return BB->getParent() ? BB->getParent()->getParent() : 0;
53 else if (const Instruction *I = dyn_cast<Instruction>(V)) {
54 const Function *M = I->getParent() ? I->getParent()->getParent() : 0;
55 return M ? M->getParent() : 0;
56 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
57 return GV->getParent();
61 static SlotCalculator *createSlotCalculator(const Value *V) {
62 assert(!isa<Type>(V) && "Can't create an SC for a type!");
63 if (const Argument *FA = dyn_cast<Argument>(V)) {
64 return new SlotCalculator(FA->getParent(), true);
65 } else if (const Instruction *I = dyn_cast<Instruction>(V)) {
66 return new SlotCalculator(I->getParent()->getParent(), true);
67 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
68 return new SlotCalculator(BB->getParent(), true);
69 } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){
70 return new SlotCalculator(GV->getParent(), true);
71 } else if (const Function *Func = dyn_cast<Function>(V)) {
72 return new SlotCalculator(Func, true);
77 // getLLVMName - Turn the specified string into an 'LLVM name', which is either
78 // prefixed with % (if the string only contains simple characters) or is
79 // surrounded with ""'s (if it has special chars in it).
80 static std::string getLLVMName(const std::string &Name) {
81 assert(!Name.empty() && "Cannot get empty name!");
83 // First character cannot start with a number...
84 if (Name[0] >= '0' && Name[0] <= '9')
85 return "\"" + Name + "\"";
87 // Scan to see if we have any characters that are not on the "white list"
88 for (unsigned i = 0, e = Name.size(); i != e; ++i) {
90 assert(C != '"' && "Illegal character in LLVM value name!");
91 if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') &&
92 C != '-' && C != '.' && C != '_')
93 return "\"" + Name + "\"";
96 // If we get here, then the identifier is legal to use as a "VarID".
101 // If the module has a symbol table, take all global types and stuff their
102 // names into the TypeNames map.
104 static void fillTypeNameTable(const Module *M,
105 std::map<const Type *, std::string> &TypeNames) {
107 const SymbolTable &ST = M->getSymbolTable();
108 SymbolTable::const_iterator PI = ST.find(Type::TypeTy);
109 if (PI != ST.end()) {
110 SymbolTable::type_const_iterator I = PI->second.begin();
111 for (; I != PI->second.end(); ++I) {
112 // As a heuristic, don't insert pointer to primitive types, because
113 // they are used too often to have a single useful name.
115 const Type *Ty = cast<Type>(I->second);
116 if (!isa<PointerType>(Ty) ||
117 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() ||
118 isa<OpaqueType>(cast<PointerType>(Ty)->getElementType()))
119 TypeNames.insert(std::make_pair(Ty, getLLVMName(I->first)));
126 static std::string calcTypeName(const Type *Ty,
127 std::vector<const Type *> &TypeStack,
128 std::map<const Type *, std::string> &TypeNames){
129 if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))
130 return Ty->getDescription(); // Base case
132 // Check to see if the type is named.
133 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
134 if (I != TypeNames.end()) return I->second;
136 if (isa<OpaqueType>(Ty))
139 // Check to see if the Type is already on the stack...
140 unsigned Slot = 0, CurSize = TypeStack.size();
141 while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type
143 // This is another base case for the recursion. In this case, we know
144 // that we have looped back to a type that we have previously visited.
145 // Generate the appropriate upreference to handle this.
148 return "\\" + utostr(CurSize-Slot); // Here's the upreference
150 TypeStack.push_back(Ty); // Recursive case: Add us to the stack..
153 switch (Ty->getPrimitiveID()) {
154 case Type::FunctionTyID: {
155 const FunctionType *FTy = cast<FunctionType>(Ty);
156 Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " (";
157 for (FunctionType::ParamTypes::const_iterator
158 I = FTy->getParamTypes().begin(),
159 E = FTy->getParamTypes().end(); I != E; ++I) {
160 if (I != FTy->getParamTypes().begin())
162 Result += calcTypeName(*I, TypeStack, TypeNames);
164 if (FTy->isVarArg()) {
165 if (!FTy->getParamTypes().empty()) Result += ", ";
171 case Type::StructTyID: {
172 const StructType *STy = cast<StructType>(Ty);
174 for (StructType::ElementTypes::const_iterator
175 I = STy->getElementTypes().begin(),
176 E = STy->getElementTypes().end(); I != E; ++I) {
177 if (I != STy->getElementTypes().begin())
179 Result += calcTypeName(*I, TypeStack, TypeNames);
184 case Type::PointerTyID:
185 Result = calcTypeName(cast<PointerType>(Ty)->getElementType(),
186 TypeStack, TypeNames) + "*";
188 case Type::ArrayTyID: {
189 const ArrayType *ATy = cast<ArrayType>(Ty);
190 Result = "[" + utostr(ATy->getNumElements()) + " x ";
191 Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]";
194 case Type::OpaqueTyID:
198 Result = "<unrecognized-type>";
201 TypeStack.pop_back(); // Remove self from stack...
206 // printTypeInt - The internal guts of printing out a type that has a
207 // potentially named portion.
209 static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,
210 std::map<const Type *, std::string> &TypeNames) {
211 // Primitive types always print out their description, regardless of whether
212 // they have been named or not.
214 if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))
215 return Out << Ty->getDescription();
217 // Check to see if the type is named.
218 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
219 if (I != TypeNames.end()) return Out << I->second;
221 // Otherwise we have a type that has not been named but is a derived type.
222 // Carefully recurse the type hierarchy to print out any contained symbolic
225 std::vector<const Type *> TypeStack;
226 std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames);
227 TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use
228 return Out << TypeName;
232 // WriteTypeSymbolic - This attempts to write the specified type as a symbolic
233 // type, iff there is an entry in the modules symbol table for the specified
234 // type or one of it's component types. This is slower than a simple x << Type;
236 std::ostream &WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
240 // If they want us to print out a type, attempt to make it symbolic if there
241 // is a symbol table in the module...
243 std::map<const Type *, std::string> TypeNames;
244 fillTypeNameTable(M, TypeNames);
246 return printTypeInt(Out, Ty, TypeNames);
248 return Out << Ty->getDescription();
252 static void WriteConstantInt(std::ostream &Out, const Constant *CV,
254 std::map<const Type *, std::string> &TypeTable,
255 SlotCalculator *Table) {
256 if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
257 Out << (CB == ConstantBool::True ? "true" : "false");
258 } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) {
259 Out << CI->getValue();
260 } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) {
261 Out << CI->getValue();
262 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
263 // We would like to output the FP constant value in exponential notation,
264 // but we cannot do this if doing so will lose precision. Check here to
265 // make sure that we only output it in exponential format if we can parse
266 // the value back and get the same value.
268 std::string StrVal = ftostr(CFP->getValue());
270 // Check to make sure that the stringized number is not some string like
271 // "Inf" or NaN, that atof will accept, but the lexer will not. Check that
272 // the string matches the "[-+]?[0-9]" regex.
274 if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
275 ((StrVal[0] == '-' || StrVal[0] == '+') &&
276 (StrVal[1] >= '0' && StrVal[1] <= '9')))
277 // Reparse stringized version!
278 if (atof(StrVal.c_str()) == CFP->getValue()) {
279 Out << StrVal; return;
282 // Otherwise we could not reparse it to exactly the same value, so we must
283 // output the string in hexadecimal format!
285 // Behave nicely in the face of C TBAA rules... see:
286 // http://www.nullstone.com/htmls/category/aliastyp.htm
288 double Val = CFP->getValue();
289 char *Ptr = (char*)&Val;
290 assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 &&
291 "assuming that double is 64 bits!");
292 Out << "0x" << utohexstr(*(uint64_t*)Ptr);
294 } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
295 if (CA->getNumOperands() > 5 && CA->isNullValue()) {
296 Out << "zeroinitializer";
300 // As a special case, print the array as a string if it is an array of
301 // ubytes or an array of sbytes with positive values.
303 const Type *ETy = CA->getType()->getElementType();
304 bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
306 if (ETy == Type::SByteTy)
307 for (unsigned i = 0; i < CA->getNumOperands(); ++i)
308 if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) {
315 for (unsigned i = 0; i < CA->getNumOperands(); ++i) {
316 unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue();
318 if (isprint(C) && C != '"' && C != '\\') {
322 << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
323 << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
328 } else { // Cannot output in string format...
330 if (CA->getNumOperands()) {
332 printTypeInt(Out, ETy, TypeTable);
333 WriteAsOperandInternal(Out, CA->getOperand(0),
334 PrintName, TypeTable, Table);
335 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
337 printTypeInt(Out, ETy, TypeTable);
338 WriteAsOperandInternal(Out, CA->getOperand(i), PrintName,
344 } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
345 if (CS->getNumOperands() > 5 && CS->isNullValue()) {
346 Out << "zeroinitializer";
351 if (CS->getNumOperands()) {
353 printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
355 WriteAsOperandInternal(Out, CS->getOperand(0),
356 PrintName, TypeTable, Table);
358 for (unsigned i = 1; i < CS->getNumOperands(); i++) {
360 printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
362 WriteAsOperandInternal(Out, CS->getOperand(i),
363 PrintName, TypeTable, Table);
368 } else if (isa<ConstantPointerNull>(CV)) {
371 } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) {
372 const GlobalValue *V = PR->getValue();
374 Out << getLLVMName(V->getName());
376 int Slot = Table->getSlot(V);
380 Out << "<pointer reference badref>";
382 Out << "<pointer reference without context info>";
385 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
386 Out << CE->getOpcodeName() << " (";
388 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
389 printTypeInt(Out, (*OI)->getType(), TypeTable);
390 WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table);
391 if (OI+1 != CE->op_end())
395 if (CE->getOpcode() == Instruction::Cast) {
397 printTypeInt(Out, CE->getType(), TypeTable);
402 Out << "<placeholder or erroneous Constant>";
407 // WriteAsOperand - Write the name of the specified value out to the specified
408 // ostream. This can be useful when you just want to print int %reg126, not the
409 // whole instruction that generated it.
411 static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
413 std::map<const Type*, std::string> &TypeTable,
414 SlotCalculator *Table) {
416 if (PrintName && V->hasName()) {
417 Out << getLLVMName(V->getName());
419 if (const Constant *CV = dyn_cast<Constant>(V)) {
420 WriteConstantInt(Out, CV, PrintName, TypeTable, Table);
424 Slot = Table->getSlot(V);
426 if (const Type *Ty = dyn_cast<Type>(V)) {
427 Out << Ty->getDescription();
431 Table = createSlotCalculator(V);
432 if (Table == 0) { Out << "BAD VALUE TYPE!"; return; }
434 Slot = Table->getSlot(V);
437 if (Slot >= 0) Out << "%" << Slot;
439 Out << "<badref>"; // Not embedded into a location?
446 // WriteAsOperand - Write the name of the specified value out to the specified
447 // ostream. This can be useful when you just want to print int %reg126, not the
448 // whole instruction that generated it.
450 std::ostream &WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
451 bool PrintName, const Module *Context) {
452 std::map<const Type *, std::string> TypeNames;
453 if (Context == 0) Context = getModuleFromVal(V);
456 fillTypeNameTable(Context, TypeNames);
459 printTypeInt(Out, V->getType(), TypeNames);
461 WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0);
467 class AssemblyWriter {
469 SlotCalculator &Table;
470 const Module *TheModule;
471 std::map<const Type *, std::string> TypeNames;
472 AssemblyAnnotationWriter *AnnotationWriter;
474 inline AssemblyWriter(std::ostream &o, SlotCalculator &Tab, const Module *M,
475 AssemblyAnnotationWriter *AAW)
476 : Out(o), Table(Tab), TheModule(M), AnnotationWriter(AAW) {
478 // If the module has a symbol table, take all global types and stuff their
479 // names into the TypeNames map.
481 fillTypeNameTable(M, TypeNames);
484 inline void write(const Module *M) { printModule(M); }
485 inline void write(const GlobalVariable *G) { printGlobal(G); }
486 inline void write(const Function *F) { printFunction(F); }
487 inline void write(const BasicBlock *BB) { printBasicBlock(BB); }
488 inline void write(const Instruction *I) { printInstruction(*I); }
489 inline void write(const Constant *CPV) { printConstant(CPV); }
490 inline void write(const Type *Ty) { printType(Ty); }
492 void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
495 void printModule(const Module *M);
496 void printSymbolTable(const SymbolTable &ST);
497 void printConstant(const Constant *CPV);
498 void printGlobal(const GlobalVariable *GV);
499 void printFunction(const Function *F);
500 void printArgument(const Argument *FA);
501 void printBasicBlock(const BasicBlock *BB);
502 void printInstruction(const Instruction &I);
504 // printType - Go to extreme measures to attempt to print out a short,
505 // symbolic version of a type name.
507 std::ostream &printType(const Type *Ty) {
508 return printTypeInt(Out, Ty, TypeNames);
511 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
512 // without considering any symbolic types that we may have equal to it.
514 std::ostream &printTypeAtLeastOneLevel(const Type *Ty);
516 // printInfoComment - Print a little comment after the instruction indicating
517 // which slot it occupies.
518 void printInfoComment(const Value &V);
522 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
523 // without considering any symbolic types that we may have equal to it.
525 std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) {
526 if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
527 printType(FTy->getReturnType()) << " (";
528 for (FunctionType::ParamTypes::const_iterator
529 I = FTy->getParamTypes().begin(),
530 E = FTy->getParamTypes().end(); I != E; ++I) {
531 if (I != FTy->getParamTypes().begin())
535 if (FTy->isVarArg()) {
536 if (!FTy->getParamTypes().empty()) Out << ", ";
540 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
542 for (StructType::ElementTypes::const_iterator
543 I = STy->getElementTypes().begin(),
544 E = STy->getElementTypes().end(); I != E; ++I) {
545 if (I != STy->getElementTypes().begin())
550 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
551 printType(PTy->getElementType()) << "*";
552 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
553 Out << "[" << ATy->getNumElements() << " x ";
554 printType(ATy->getElementType()) << "]";
555 } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
558 if (!Ty->isPrimitiveType())
559 Out << "<unknown derived type>";
566 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType,
568 if (PrintType) { Out << " "; printType(Operand->getType()); }
569 WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Table);
573 void AssemblyWriter::printModule(const Module *M) {
574 switch (M->getEndianness()) {
575 case Module::LittleEndian: Out << "target endian = little\n"; break;
576 case Module::BigEndian: Out << "target endian = big\n"; break;
577 case Module::AnyEndianness: break;
579 switch (M->getPointerSize()) {
580 case Module::Pointer32: Out << "target pointersize = 32\n"; break;
581 case Module::Pointer64: Out << "target pointersize = 64\n"; break;
582 case Module::AnyPointerSize: break;
585 // Loop over the symbol table, emitting all named constants...
586 printSymbolTable(M->getSymbolTable());
588 for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
591 Out << "\nimplementation ; Functions:\n";
593 // Output all of the functions...
594 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
598 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
599 if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = ";
601 if (!GV->hasInitializer())
604 switch (GV->getLinkage()) {
605 case GlobalValue::InternalLinkage: Out << "internal "; break;
606 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
607 case GlobalValue::WeakLinkage: Out << "weak "; break;
608 case GlobalValue::AppendingLinkage: Out << "appending "; break;
609 case GlobalValue::ExternalLinkage: break;
612 Out << (GV->isConstant() ? "constant " : "global ");
613 printType(GV->getType()->getElementType());
615 if (GV->hasInitializer())
616 writeOperand(GV->getInitializer(), false, false);
618 printInfoComment(*GV);
623 // printSymbolTable - Run through symbol table looking for named constants
624 // if a named constant is found, emit it's declaration...
626 void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
627 for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) {
628 SymbolTable::type_const_iterator I = ST.type_begin(TI->first);
629 SymbolTable::type_const_iterator End = ST.type_end(TI->first);
631 for (; I != End; ++I) {
632 const Value *V = I->second;
633 if (const Constant *CPV = dyn_cast<Constant>(V)) {
635 } else if (const Type *Ty = dyn_cast<Type>(V)) {
636 assert(Ty->getType() == Type::TypeTy && TI->first == Type::TypeTy);
637 Out << "\t" << getLLVMName(I->first) << " = type ";
639 // Make sure we print out at least one level of the type structure, so
640 // that we do not get %FILE = type %FILE
642 printTypeAtLeastOneLevel(Ty) << "\n";
649 // printConstant - Print out a constant pool entry...
651 void AssemblyWriter::printConstant(const Constant *CPV) {
652 // Don't print out unnamed constants, they will be inlined
653 if (!CPV->hasName()) return;
656 Out << "\t" << getLLVMName(CPV->getName()) << " =";
658 // Write the value out now...
659 writeOperand(CPV, true, false);
661 printInfoComment(*CPV);
665 // printFunction - Print all aspects of a function.
667 void AssemblyWriter::printFunction(const Function *F) {
668 // Print out the return type and name...
671 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
676 switch (F->getLinkage()) {
677 case GlobalValue::InternalLinkage: Out << "internal "; break;
678 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
679 case GlobalValue::WeakLinkage: Out << "weak "; break;
680 case GlobalValue::AppendingLinkage: Out << "appending "; break;
681 case GlobalValue::ExternalLinkage: break;
684 printType(F->getReturnType()) << " ";
685 if (!F->getName().empty())
686 Out << getLLVMName(F->getName());
690 Table.incorporateFunction(F);
692 // Loop over the arguments, printing them...
693 const FunctionType *FT = F->getFunctionType();
695 for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I)
698 // Finish printing arguments...
699 if (FT->isVarArg()) {
700 if (FT->getParamTypes().size()) Out << ", ";
701 Out << "..."; // Output varargs portion of signature!
705 if (F->isExternal()) {
710 // Output all of its basic blocks... for the function
711 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
717 Table.purgeFunction();
720 // printArgument - This member is called for every argument that
721 // is passed into the function. Simply print it out
723 void AssemblyWriter::printArgument(const Argument *Arg) {
724 // Insert commas as we go... the first arg doesn't get a comma
725 if (Arg != &Arg->getParent()->afront()) Out << ", ";
728 printType(Arg->getType());
730 // Output name, if available...
732 Out << " " << getLLVMName(Arg->getName());
733 else if (Table.getSlot(Arg) < 0)
737 // printBasicBlock - This member is called for each basic block in a method.
739 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
740 if (BB->hasName()) { // Print out the label if it exists...
741 Out << "\n" << BB->getName() << ":";
742 } else if (!BB->use_empty()) { // Don't print block # of no uses...
743 int Slot = Table.getSlot(BB);
744 Out << "\n; <label>:";
746 Out << Slot; // Extra newline separates out label's
751 // Output predecessors for the block...
753 pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
756 Out << " No predecessors!";
759 writeOperand(*PI, false, true);
760 for (++PI; PI != PE; ++PI) {
762 writeOperand(*PI, false, true);
768 if (AnnotationWriter) AnnotationWriter->emitBasicBlockAnnot(BB, Out);
770 // Output all of the instructions in the basic block...
771 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
772 printInstruction(*I);
776 // printInfoComment - Print a little comment after the instruction indicating
777 // which slot it occupies.
779 void AssemblyWriter::printInfoComment(const Value &V) {
780 if (V.getType() != Type::VoidTy) {
782 printType(V.getType()) << ">";
785 int Slot = Table.getSlot(&V); // Print out the def slot taken...
786 if (Slot >= 0) Out << ":" << Slot;
787 else Out << ":<badref>";
789 Out << " [#uses=" << V.use_size() << "]"; // Output # uses
793 // printInstruction - This member is called for each Instruction in a method.
795 void AssemblyWriter::printInstruction(const Instruction &I) {
796 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
800 // Print out name if it exists...
802 Out << getLLVMName(I.getName()) << " = ";
804 // If this is a volatile load or store, print out the volatile marker
805 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
806 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()))
809 // Print out the opcode...
810 Out << I.getOpcodeName();
812 // Print out the type of the operands...
813 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
815 // Special case conditional branches to swizzle the condition out to the front
816 if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
817 writeOperand(I.getOperand(2), true);
819 writeOperand(Operand, true);
821 writeOperand(I.getOperand(1), true);
823 } else if (isa<SwitchInst>(I)) {
824 // Special case switch statement to get formatting nice and correct...
825 writeOperand(Operand , true); Out << ",";
826 writeOperand(I.getOperand(1), true); Out << " [";
828 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
830 writeOperand(I.getOperand(op ), true); Out << ",";
831 writeOperand(I.getOperand(op+1), true);
834 } else if (isa<PHINode>(I)) {
836 printType(I.getType());
839 for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
842 writeOperand(I.getOperand(op ), false); Out << ",";
843 writeOperand(I.getOperand(op+1), false); Out << " ]";
845 } else if (isa<ReturnInst>(I) && !Operand) {
847 } else if (isa<CallInst>(I)) {
848 const PointerType *PTy = cast<PointerType>(Operand->getType());
849 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
850 const Type *RetTy = FTy->getReturnType();
852 // If possible, print out the short form of the call instruction. We can
853 // only do this if the first argument is a pointer to a nonvararg function,
854 // and if the return type is not a pointer to a function.
856 if (!FTy->isVarArg() &&
857 (!isa<PointerType>(RetTy) ||
858 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
859 Out << " "; printType(RetTy);
860 writeOperand(Operand, false);
862 writeOperand(Operand, true);
865 if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true);
866 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) {
868 writeOperand(I.getOperand(op), true);
872 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
873 const PointerType *PTy = cast<PointerType>(Operand->getType());
874 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
875 const Type *RetTy = FTy->getReturnType();
877 // If possible, print out the short form of the invoke instruction. We can
878 // only do this if the first argument is a pointer to a nonvararg function,
879 // and if the return type is not a pointer to a function.
881 if (!FTy->isVarArg() &&
882 (!isa<PointerType>(RetTy) ||
883 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
884 Out << " "; printType(RetTy);
885 writeOperand(Operand, false);
887 writeOperand(Operand, true);
891 if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true);
892 for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) {
894 writeOperand(I.getOperand(op), true);
897 Out << " )\n\t\t\tto";
898 writeOperand(II->getNormalDest(), true);
900 writeOperand(II->getExceptionalDest(), true);
902 } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
904 printType(AI->getType()->getElementType());
905 if (AI->isArrayAllocation()) {
907 writeOperand(AI->getArraySize(), true);
909 } else if (isa<CastInst>(I)) {
910 writeOperand(Operand, true);
912 printType(I.getType());
913 } else if (isa<VAArgInst>(I)) {
914 writeOperand(Operand, true);
916 printType(I.getType());
917 } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) {
918 writeOperand(Operand, true);
920 printType(VAN->getArgType());
921 } else if (Operand) { // Print the normal way...
923 // PrintAllTypes - Instructions who have operands of all the same type
924 // omit the type from all but the first operand. If the instruction has
925 // different type operands (for example br), then they are all printed.
926 bool PrintAllTypes = false;
927 const Type *TheType = Operand->getType();
929 // Shift Left & Right print both types even for Ubyte LHS
930 if (isa<ShiftInst>(I)) {
931 PrintAllTypes = true;
933 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
934 Operand = I.getOperand(i);
935 if (Operand->getType() != TheType) {
936 PrintAllTypes = true; // We have differing types! Print them all!
942 if (!PrintAllTypes) {
947 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
949 writeOperand(I.getOperand(i), PrintAllTypes);
958 //===----------------------------------------------------------------------===//
959 // External Interface declarations
960 //===----------------------------------------------------------------------===//
962 void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
963 SlotCalculator SlotTable(this, true);
964 AssemblyWriter W(o, SlotTable, this, AAW);
968 void GlobalVariable::print(std::ostream &o) const {
969 SlotCalculator SlotTable(getParent(), true);
970 AssemblyWriter W(o, SlotTable, getParent(), 0);
974 void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
975 SlotCalculator SlotTable(getParent(), true);
976 AssemblyWriter W(o, SlotTable, getParent(), AAW);
981 void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
982 SlotCalculator SlotTable(getParent(), true);
983 AssemblyWriter W(o, SlotTable,
984 getParent() ? getParent()->getParent() : 0, AAW);
988 void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
989 const Function *F = getParent() ? getParent()->getParent() : 0;
990 SlotCalculator SlotTable(F, true);
991 AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW);
996 void Constant::print(std::ostream &o) const {
997 if (this == 0) { o << "<null> constant value\n"; return; }
999 // Handle CPR's special, because they have context information...
1000 if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) {
1001 CPR->getValue()->print(o); // Print as a global value, with context info.
1005 o << " " << getType()->getDescription() << " ";
1007 std::map<const Type *, std::string> TypeTable;
1008 WriteConstantInt(o, this, false, TypeTable, 0);
1011 void Type::print(std::ostream &o) const {
1015 o << getDescription();
1018 void Argument::print(std::ostream &o) const {
1019 o << getType() << " " << getName();
1022 void Value::dump() const { print(std::cerr); }
1024 //===----------------------------------------------------------------------===//
1025 // CachedWriter Class Implementation
1026 //===----------------------------------------------------------------------===//
1028 void CachedWriter::setModule(const Module *M) {
1029 delete SC; delete AW;
1031 SC = new SlotCalculator(M, true);
1032 AW = new AssemblyWriter(Out, *SC, M, 0);
1038 CachedWriter::~CachedWriter() {
1043 CachedWriter &CachedWriter::operator<<(const Value *V) {
1044 assert(AW && SC && "CachedWriter does not have a current module!");
1045 switch (V->getValueType()) {
1046 case Value::ConstantVal:
1047 case Value::ArgumentVal: AW->writeOperand(V, true, true); break;
1048 case Value::TypeVal: AW->write(cast<Type>(V)); break;
1049 case Value::InstructionVal: AW->write(cast<Instruction>(V)); break;
1050 case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break;
1051 case Value::FunctionVal: AW->write(cast<Function>(V)); break;
1052 case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break;
1053 default: Out << "<unknown value type: " << V->getValueType() << ">"; break;
1058 } // End llvm namespace