AsmWriter.cpp revision 9231ac8b6f2c3f9877bdb7a223f7392061258ab6
1//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2// 3// 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. 7// 8//===----------------------------------------------------------------------===// 9// 10// This library implements the functionality defined in llvm/Assembly/Writer.h 11// 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. 14// 15//===----------------------------------------------------------------------===// 16 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/Constants.h" 22#include "llvm/DerivedTypes.h" 23#include "llvm/Instruction.h" 24#include "llvm/iMemory.h" 25#include "llvm/iTerminators.h" 26#include "llvm/iPHINode.h" 27#include "llvm/iOther.h" 28#include "llvm/Module.h" 29#include "llvm/SymbolTable.h" 30#include "llvm/Analysis/SlotCalculator.h" 31#include "llvm/Assembly/Writer.h" 32#include "llvm/Support/CFG.h" 33#include "Support/StringExtras.h" 34#include "Support/STLExtras.h" 35#include <algorithm> 36using namespace llvm; 37 38static RegisterPass<PrintModulePass> 39X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); 40static RegisterPass<PrintFunctionPass> 41Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); 42 43static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 44 bool PrintName, 45 std::map<const Type *, std::string> &TypeTable, 46 SlotCalculator *Table); 47 48static 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(); 58 return 0; 59} 60 61static 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(), false); 65 } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 66 return new SlotCalculator(I->getParent()->getParent(), false); 67 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 68 return new SlotCalculator(BB->getParent(), false); 69 } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 70 return new SlotCalculator(GV->getParent(), false); 71 } else if (const Function *Func = dyn_cast<Function>(V)) { 72 return new SlotCalculator(Func, false); 73 } 74 return 0; 75} 76 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). 80static std::string getLLVMName(const std::string &Name) { 81 assert(!Name.empty() && "Cannot get empty name!"); 82 83 // First character cannot start with a number... 84 if (Name[0] >= '0' && Name[0] <= '9') 85 return "\"" + Name + "\""; 86 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) { 89 char C = Name[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 + "\""; 94 } 95 96 // If we get here, then the identifier is legal to use as a "VarID". 97 return "%"+Name; 98} 99 100 101/// fillTypeNameTable - If the module has a symbol table, take all global types 102/// and stuff their names into the TypeNames map. 103/// 104static void fillTypeNameTable(const Module *M, 105 std::map<const Type *, std::string> &TypeNames) { 106 if (!M) return; 107 const SymbolTable &ST = M->getSymbolTable(); 108 SymbolTable::type_const_iterator TI = ST.type_begin(); 109 for (; TI != ST.type_end(); ++TI ) { 110 // As a heuristic, don't insert pointer to primitive types, because 111 // they are used too often to have a single useful name. 112 // 113 const Type *Ty = cast<Type>(TI->second); 114 if (!isa<PointerType>(Ty) || 115 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 116 isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 117 TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); 118 } 119} 120 121 122 123static std::string calcTypeName(const Type *Ty, 124 std::vector<const Type *> &TypeStack, 125 std::map<const Type *, std::string> &TypeNames){ 126 if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 127 return Ty->getDescription(); // Base case 128 129 // Check to see if the type is named. 130 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 131 if (I != TypeNames.end()) return I->second; 132 133 if (isa<OpaqueType>(Ty)) 134 return "opaque"; 135 136 // Check to see if the Type is already on the stack... 137 unsigned Slot = 0, CurSize = TypeStack.size(); 138 while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 139 140 // This is another base case for the recursion. In this case, we know 141 // that we have looped back to a type that we have previously visited. 142 // Generate the appropriate upreference to handle this. 143 if (Slot < CurSize) 144 return "\\" + utostr(CurSize-Slot); // Here's the upreference 145 146 TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 147 148 std::string Result; 149 switch (Ty->getPrimitiveID()) { 150 case Type::FunctionTyID: { 151 const FunctionType *FTy = cast<FunctionType>(Ty); 152 Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; 153 for (FunctionType::param_iterator I = FTy->param_begin(), 154 E = FTy->param_end(); I != E; ++I) { 155 if (I != FTy->param_begin()) 156 Result += ", "; 157 Result += calcTypeName(*I, TypeStack, TypeNames); 158 } 159 if (FTy->isVarArg()) { 160 if (FTy->getNumParams()) Result += ", "; 161 Result += "..."; 162 } 163 Result += ")"; 164 break; 165 } 166 case Type::StructTyID: { 167 const StructType *STy = cast<StructType>(Ty); 168 Result = "{ "; 169 for (StructType::element_iterator I = STy->element_begin(), 170 E = STy->element_end(); I != E; ++I) { 171 if (I != STy->element_begin()) 172 Result += ", "; 173 Result += calcTypeName(*I, TypeStack, TypeNames); 174 } 175 Result += " }"; 176 break; 177 } 178 case Type::PointerTyID: 179 Result = calcTypeName(cast<PointerType>(Ty)->getElementType(), 180 TypeStack, TypeNames) + "*"; 181 break; 182 case Type::ArrayTyID: { 183 const ArrayType *ATy = cast<ArrayType>(Ty); 184 Result = "[" + utostr(ATy->getNumElements()) + " x "; 185 Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; 186 break; 187 } 188 case Type::OpaqueTyID: 189 Result = "opaque"; 190 break; 191 default: 192 Result = "<unrecognized-type>"; 193 } 194 195 TypeStack.pop_back(); // Remove self from stack... 196 return Result; 197} 198 199 200/// printTypeInt - The internal guts of printing out a type that has a 201/// potentially named portion. 202/// 203static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 204 std::map<const Type *, std::string> &TypeNames) { 205 // Primitive types always print out their description, regardless of whether 206 // they have been named or not. 207 // 208 if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) 209 return Out << Ty->getDescription(); 210 211 // Check to see if the type is named. 212 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 213 if (I != TypeNames.end()) return Out << I->second; 214 215 // Otherwise we have a type that has not been named but is a derived type. 216 // Carefully recurse the type hierarchy to print out any contained symbolic 217 // names. 218 // 219 std::vector<const Type *> TypeStack; 220 std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames); 221 TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 222 return Out << TypeName; 223} 224 225 226/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 227/// type, iff there is an entry in the modules symbol table for the specified 228/// type or one of it's component types. This is slower than a simple x << Type 229/// 230std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 231 const Module *M) { 232 Out << " "; 233 234 // If they want us to print out a type, attempt to make it symbolic if there 235 // is a symbol table in the module... 236 if (M) { 237 std::map<const Type *, std::string> TypeNames; 238 fillTypeNameTable(M, TypeNames); 239 240 return printTypeInt(Out, Ty, TypeNames); 241 } else { 242 return Out << Ty->getDescription(); 243 } 244} 245 246static void WriteConstantInt(std::ostream &Out, const Constant *CV, 247 bool PrintName, 248 std::map<const Type *, std::string> &TypeTable, 249 SlotCalculator *Table) { 250 if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { 251 Out << (CB == ConstantBool::True ? "true" : "false"); 252 } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) { 253 Out << CI->getValue(); 254 } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) { 255 Out << CI->getValue(); 256 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 257 // We would like to output the FP constant value in exponential notation, 258 // but we cannot do this if doing so will lose precision. Check here to 259 // make sure that we only output it in exponential format if we can parse 260 // the value back and get the same value. 261 // 262 std::string StrVal = ftostr(CFP->getValue()); 263 264 // Check to make sure that the stringized number is not some string like 265 // "Inf" or NaN, that atof will accept, but the lexer will not. Check that 266 // the string matches the "[-+]?[0-9]" regex. 267 // 268 if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 269 ((StrVal[0] == '-' || StrVal[0] == '+') && 270 (StrVal[1] >= '0' && StrVal[1] <= '9'))) 271 // Reparse stringized version! 272 if (atof(StrVal.c_str()) == CFP->getValue()) { 273 Out << StrVal; return; 274 } 275 276 // Otherwise we could not reparse it to exactly the same value, so we must 277 // output the string in hexadecimal format! 278 // 279 // Behave nicely in the face of C TBAA rules... see: 280 // http://www.nullstone.com/htmls/category/aliastyp.htm 281 // 282 double Val = CFP->getValue(); 283 char *Ptr = (char*)&Val; 284 assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 && 285 "assuming that double is 64 bits!"); 286 Out << "0x" << utohexstr(*(uint64_t*)Ptr); 287 288 } else if (isa<ConstantAggregateZero>(CV)) { 289 Out << "zeroinitializer"; 290 } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 291 // As a special case, print the array as a string if it is an array of 292 // ubytes or an array of sbytes with positive values. 293 // 294 const Type *ETy = CA->getType()->getElementType(); 295 bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy); 296 297 if (ETy == Type::SByteTy) 298 for (unsigned i = 0; i < CA->getNumOperands(); ++i) 299 if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) { 300 isString = false; 301 break; 302 } 303 304 if (isString) { 305 Out << "c\""; 306 for (unsigned i = 0; i < CA->getNumOperands(); ++i) { 307 unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue(); 308 309 if (isprint(C) && C != '"' && C != '\\') { 310 Out << C; 311 } else { 312 Out << '\\' 313 << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 314 << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 315 } 316 } 317 Out << "\""; 318 319 } else { // Cannot output in string format... 320 Out << "["; 321 if (CA->getNumOperands()) { 322 Out << " "; 323 printTypeInt(Out, ETy, TypeTable); 324 WriteAsOperandInternal(Out, CA->getOperand(0), 325 PrintName, TypeTable, Table); 326 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 327 Out << ", "; 328 printTypeInt(Out, ETy, TypeTable); 329 WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, 330 TypeTable, Table); 331 } 332 } 333 Out << " ]"; 334 } 335 } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 336 Out << "{"; 337 if (CS->getNumOperands()) { 338 Out << " "; 339 printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 340 341 WriteAsOperandInternal(Out, CS->getOperand(0), 342 PrintName, TypeTable, Table); 343 344 for (unsigned i = 1; i < CS->getNumOperands(); i++) { 345 Out << ", "; 346 printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 347 348 WriteAsOperandInternal(Out, CS->getOperand(i), 349 PrintName, TypeTable, Table); 350 } 351 } 352 353 Out << " }"; 354 } else if (isa<ConstantPointerNull>(CV)) { 355 Out << "null"; 356 357 } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { 358 WriteAsOperandInternal(Out, PR->getValue(), true, TypeTable, Table); 359 360 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 361 Out << CE->getOpcodeName() << " ("; 362 363 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 364 printTypeInt(Out, (*OI)->getType(), TypeTable); 365 WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table); 366 if (OI+1 != CE->op_end()) 367 Out << ", "; 368 } 369 370 if (CE->getOpcode() == Instruction::Cast) { 371 Out << " to "; 372 printTypeInt(Out, CE->getType(), TypeTable); 373 } 374 Out << ")"; 375 376 } else { 377 Out << "<placeholder or erroneous Constant>"; 378 } 379} 380 381 382/// WriteAsOperand - Write the name of the specified value out to the specified 383/// ostream. This can be useful when you just want to print int %reg126, not 384/// the whole instruction that generated it. 385/// 386static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 387 bool PrintName, 388 std::map<const Type*, std::string> &TypeTable, 389 SlotCalculator *Table) { 390 Out << " "; 391 if (PrintName && V->hasName()) { 392 Out << getLLVMName(V->getName()); 393 } else { 394 if (const Constant *CV = dyn_cast<Constant>(V)) { 395 WriteConstantInt(Out, CV, PrintName, TypeTable, Table); 396 } else { 397 int Slot; 398 if (Table) { 399 Slot = Table->getSlot(V); 400 } else { 401 if (const Type *Ty = dyn_cast<Type>(V)) { 402 Out << Ty->getDescription(); 403 return; 404 } 405 406 Table = createSlotCalculator(V); 407 if (Table == 0) { Out << "BAD VALUE TYPE!"; return; } 408 409 Slot = Table->getSlot(V); 410 delete Table; 411 } 412 if (Slot >= 0) Out << "%" << Slot; 413 else if (PrintName) 414 if (V->hasName()) 415 Out << "<badref: " << getLLVMName(V->getName()) << ">"; 416 else 417 Out << "<badref>"; // Not embedded into a location? 418 } 419 } 420} 421 422 423/// WriteAsOperand - Write the name of the specified value out to the specified 424/// ostream. This can be useful when you just want to print int %reg126, not 425/// the whole instruction that generated it. 426/// 427std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 428 bool PrintType, bool PrintName, 429 const Module *Context) { 430 std::map<const Type *, std::string> TypeNames; 431 if (Context == 0) Context = getModuleFromVal(V); 432 433 if (Context) 434 fillTypeNameTable(Context, TypeNames); 435 436 if (PrintType) 437 printTypeInt(Out, V->getType(), TypeNames); 438 439 if (const Type *Ty = dyn_cast<Type> (V)) 440 printTypeInt(Out, Ty, TypeNames); 441 442 WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); 443 return Out; 444} 445 446namespace llvm { 447 448class AssemblyWriter { 449 std::ostream *Out; 450 SlotCalculator &Table; 451 const Module *TheModule; 452 std::map<const Type *, std::string> TypeNames; 453 AssemblyAnnotationWriter *AnnotationWriter; 454public: 455 inline AssemblyWriter(std::ostream &o, SlotCalculator &Tab, const Module *M, 456 AssemblyAnnotationWriter *AAW) 457 : Out(&o), Table(Tab), TheModule(M), AnnotationWriter(AAW) { 458 459 // If the module has a symbol table, take all global types and stuff their 460 // names into the TypeNames map. 461 // 462 fillTypeNameTable(M, TypeNames); 463 } 464 465 inline void write(const Module *M) { printModule(M); } 466 inline void write(const GlobalVariable *G) { printGlobal(G); } 467 inline void write(const Function *F) { printFunction(F); } 468 inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 469 inline void write(const Instruction *I) { printInstruction(*I); } 470 inline void write(const Constant *CPV) { printConstant(CPV); } 471 inline void write(const Type *Ty) { printType(Ty); } 472 473 void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); 474 475 const Module* getModule() { return TheModule; } 476 void setStream(std::ostream &os) { Out = &os; } 477 478private : 479 void printModule(const Module *M); 480 void printSymbolTable(const SymbolTable &ST); 481 void printConstant(const Constant *CPV); 482 void printGlobal(const GlobalVariable *GV); 483 void printFunction(const Function *F); 484 void printArgument(const Argument *FA); 485 void printBasicBlock(const BasicBlock *BB); 486 void printInstruction(const Instruction &I); 487 488 // printType - Go to extreme measures to attempt to print out a short, 489 // symbolic version of a type name. 490 // 491 std::ostream &printType(const Type *Ty) { 492 return printTypeInt(*Out, Ty, TypeNames); 493 } 494 495 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 496 // without considering any symbolic types that we may have equal to it. 497 // 498 std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 499 500 // printInfoComment - Print a little comment after the instruction indicating 501 // which slot it occupies. 502 void printInfoComment(const Value &V); 503}; 504} // end of anonymous namespace 505 506/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 507/// without considering any symbolic types that we may have equal to it. 508/// 509std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 510 if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 511 printType(FTy->getReturnType()) << " ("; 512 for (FunctionType::param_iterator I = FTy->param_begin(), 513 E = FTy->param_end(); I != E; ++I) { 514 if (I != FTy->param_begin()) 515 *Out << ", "; 516 printType(*I); 517 } 518 if (FTy->isVarArg()) { 519 if (FTy->getNumParams()) *Out << ", "; 520 *Out << "..."; 521 } 522 *Out << ")"; 523 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 524 *Out << "{ "; 525 for (StructType::element_iterator I = STy->element_begin(), 526 E = STy->element_end(); I != E; ++I) { 527 if (I != STy->element_begin()) 528 *Out << ", "; 529 printType(*I); 530 } 531 *Out << " }"; 532 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 533 printType(PTy->getElementType()) << "*"; 534 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 535 *Out << "[" << ATy->getNumElements() << " x "; 536 printType(ATy->getElementType()) << "]"; 537 } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) { 538 *Out << "opaque"; 539 } else { 540 if (!Ty->isPrimitiveType()) 541 *Out << "<unknown derived type>"; 542 printType(Ty); 543 } 544 return *Out; 545} 546 547 548void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 549 bool PrintName) { 550 if (PrintType) { *Out << " "; printType(Operand->getType()); } 551 WriteAsOperandInternal(*Out, Operand, PrintName, TypeNames, &Table); 552} 553 554 555void AssemblyWriter::printModule(const Module *M) { 556 switch (M->getEndianness()) { 557 case Module::LittleEndian: *Out << "target endian = little\n"; break; 558 case Module::BigEndian: *Out << "target endian = big\n"; break; 559 case Module::AnyEndianness: break; 560 } 561 switch (M->getPointerSize()) { 562 case Module::Pointer32: *Out << "target pointersize = 32\n"; break; 563 case Module::Pointer64: *Out << "target pointersize = 64\n"; break; 564 case Module::AnyPointerSize: break; 565 } 566 567 // Loop over the symbol table, emitting all named constants... 568 printSymbolTable(M->getSymbolTable()); 569 570 for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 571 printGlobal(I); 572 573 *Out << "\nimplementation ; Functions:\n"; 574 575 // Output all of the functions... 576 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 577 printFunction(I); 578} 579 580void AssemblyWriter::printGlobal(const GlobalVariable *GV) { 581 if (GV->hasName()) *Out << getLLVMName(GV->getName()) << " = "; 582 583 if (!GV->hasInitializer()) 584 *Out << "external "; 585 else 586 switch (GV->getLinkage()) { 587 case GlobalValue::InternalLinkage: *Out << "internal "; break; 588 case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 589 case GlobalValue::WeakLinkage: *Out << "weak "; break; 590 case GlobalValue::AppendingLinkage: *Out << "appending "; break; 591 case GlobalValue::ExternalLinkage: break; 592 } 593 594 *Out << (GV->isConstant() ? "constant " : "global "); 595 printType(GV->getType()->getElementType()); 596 597 if (GV->hasInitializer()) 598 writeOperand(GV->getInitializer(), false, false); 599 600 printInfoComment(*GV); 601 *Out << "\n"; 602} 603 604 605// printSymbolTable - Run through symbol table looking for constants 606// and types. Emit their declarations. 607void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { 608 609 // Print the types. 610 for (SymbolTable::type_const_iterator TI = ST.type_begin(); 611 TI != ST.type_end(); ++TI ) { 612 *Out << "\t" << getLLVMName(TI->first) << " = type "; 613 614 // Make sure we print out at least one level of the type structure, so 615 // that we do not get %FILE = type %FILE 616 // 617 printTypeAtLeastOneLevel(TI->second) << "\n"; 618 } 619 620 // Print the constants, in type plane order. 621 for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); 622 PI != ST.plane_end(); ++PI ) { 623 SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); 624 SymbolTable::value_const_iterator VE = ST.value_end(PI->first); 625 626 for (; VI != VE; ++VI) { 627 const Value *V = VI->second; 628 if (const Constant *CPV = dyn_cast<Constant>(V)) { 629 printConstant(CPV); 630 } 631 } 632 } 633} 634 635 636/// printConstant - Print out a constant pool entry... 637/// 638void AssemblyWriter::printConstant(const Constant *CPV) { 639 // Don't print out unnamed constants, they will be inlined 640 if (!CPV->hasName()) return; 641 642 // Print out name... 643 *Out << "\t" << getLLVMName(CPV->getName()) << " ="; 644 645 // Write the value out now... 646 writeOperand(CPV, true, false); 647 648 printInfoComment(*CPV); 649 *Out << "\n"; 650} 651 652/// printFunction - Print all aspects of a function. 653/// 654void AssemblyWriter::printFunction(const Function *F) { 655 // Print out the return type and name... 656 *Out << "\n"; 657 658 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, *Out); 659 660 if (F->isExternal()) 661 *Out << "declare "; 662 else 663 switch (F->getLinkage()) { 664 case GlobalValue::InternalLinkage: *Out << "internal "; break; 665 case GlobalValue::LinkOnceLinkage: *Out << "linkonce "; break; 666 case GlobalValue::WeakLinkage: *Out << "weak "; break; 667 case GlobalValue::AppendingLinkage: *Out << "appending "; break; 668 case GlobalValue::ExternalLinkage: break; 669 } 670 671 printType(F->getReturnType()) << " "; 672 if (!F->getName().empty()) 673 *Out << getLLVMName(F->getName()); 674 else 675 *Out << "\"\""; 676 *Out << "("; 677 Table.incorporateFunction(F); 678 679 // Loop over the arguments, printing them... 680 const FunctionType *FT = F->getFunctionType(); 681 682 for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) 683 printArgument(I); 684 685 // Finish printing arguments... 686 if (FT->isVarArg()) { 687 if (FT->getNumParams()) *Out << ", "; 688 *Out << "..."; // Output varargs portion of signature! 689 } 690 *Out << ")"; 691 692 if (F->isExternal()) { 693 *Out << "\n"; 694 } else { 695 *Out << " {"; 696 697 // Output all of its basic blocks... for the function 698 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 699 printBasicBlock(I); 700 701 *Out << "}\n"; 702 } 703 704 Table.purgeFunction(); 705} 706 707/// printArgument - This member is called for every argument that is passed into 708/// the function. Simply print it out 709/// 710void AssemblyWriter::printArgument(const Argument *Arg) { 711 // Insert commas as we go... the first arg doesn't get a comma 712 if (Arg != &Arg->getParent()->afront()) *Out << ", "; 713 714 // Output type... 715 printType(Arg->getType()); 716 717 // Output name, if available... 718 if (Arg->hasName()) 719 *Out << " " << getLLVMName(Arg->getName()); 720 else if (Table.getSlot(Arg) < 0) 721 *Out << "<badref>"; 722} 723 724/// printBasicBlock - This member is called for each basic block in a method. 725/// 726void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 727 if (BB->hasName()) { // Print out the label if it exists... 728 *Out << "\n" << BB->getName() << ":"; 729 } else if (!BB->use_empty()) { // Don't print block # of no uses... 730 int Slot = Table.getSlot(BB); 731 *Out << "\n; <label>:"; 732 if (Slot >= 0) 733 *Out << Slot; // Extra newline separates out label's 734 else 735 *Out << "<badref>"; 736 } 737 738 if (BB->getParent() == 0) 739 *Out << "\t\t; Error: Block without parent!"; 740 else { 741 if (BB != &BB->getParent()->front()) { // Not the entry block? 742 // Output predecessors for the block... 743 *Out << "\t\t;"; 744 pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 745 746 if (PI == PE) { 747 *Out << " No predecessors!"; 748 } else { 749 *Out << " preds ="; 750 writeOperand(*PI, false, true); 751 for (++PI; PI != PE; ++PI) { 752 *Out << ","; 753 writeOperand(*PI, false, true); 754 } 755 } 756 } 757 } 758 759 *Out << "\n"; 760 761 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, *Out); 762 763 // Output all of the instructions in the basic block... 764 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 765 printInstruction(*I); 766 767 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, *Out); 768} 769 770 771/// printInfoComment - Print a little comment after the instruction indicating 772/// which slot it occupies. 773/// 774void AssemblyWriter::printInfoComment(const Value &V) { 775 if (V.getType() != Type::VoidTy) { 776 *Out << "\t\t; <"; 777 printType(V.getType()) << ">"; 778 779 if (!V.hasName()) { 780 int Slot = Table.getSlot(&V); // Print out the def slot taken... 781 if (Slot >= 0) *Out << ":" << Slot; 782 else *Out << ":<badref>"; 783 } 784 *Out << " [#uses=" << V.use_size() << "]"; // Output # uses 785 } 786} 787 788/// printInstruction - This member is called for each Instruction in a method. 789/// 790void AssemblyWriter::printInstruction(const Instruction &I) { 791 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, *Out); 792 793 *Out << "\t"; 794 795 // Print out name if it exists... 796 if (I.hasName()) 797 *Out << getLLVMName(I.getName()) << " = "; 798 799 // If this is a volatile load or store, print out the volatile marker 800 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 801 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) 802 *Out << "volatile "; 803 804 // Print out the opcode... 805 *Out << I.getOpcodeName(); 806 807 // Print out the type of the operands... 808 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 809 810 // Special case conditional branches to swizzle the condition out to the front 811 if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 812 writeOperand(I.getOperand(2), true); 813 *Out << ","; 814 writeOperand(Operand, true); 815 *Out << ","; 816 writeOperand(I.getOperand(1), true); 817 818 } else if (isa<SwitchInst>(I)) { 819 // Special case switch statement to get formatting nice and correct... 820 writeOperand(Operand , true); *Out << ","; 821 writeOperand(I.getOperand(1), true); *Out << " ["; 822 823 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 824 *Out << "\n\t\t"; 825 writeOperand(I.getOperand(op ), true); *Out << ","; 826 writeOperand(I.getOperand(op+1), true); 827 } 828 *Out << "\n\t]"; 829 } else if (isa<PHINode>(I)) { 830 *Out << " "; 831 printType(I.getType()); 832 *Out << " "; 833 834 for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 835 if (op) *Out << ", "; 836 *Out << "["; 837 writeOperand(I.getOperand(op ), false); *Out << ","; 838 writeOperand(I.getOperand(op+1), false); *Out << " ]"; 839 } 840 } else if (isa<ReturnInst>(I) && !Operand) { 841 *Out << " void"; 842 } else if (isa<CallInst>(I)) { 843 const PointerType *PTy = cast<PointerType>(Operand->getType()); 844 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 845 const Type *RetTy = FTy->getReturnType(); 846 847 // If possible, print out the short form of the call instruction. We can 848 // only do this if the first argument is a pointer to a nonvararg function, 849 // and if the return type is not a pointer to a function. 850 // 851 if (!FTy->isVarArg() && 852 (!isa<PointerType>(RetTy) || 853 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 854 *Out << " "; printType(RetTy); 855 writeOperand(Operand, false); 856 } else { 857 writeOperand(Operand, true); 858 } 859 *Out << "("; 860 if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true); 861 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) { 862 *Out << ","; 863 writeOperand(I.getOperand(op), true); 864 } 865 866 *Out << " )"; 867 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 868 const PointerType *PTy = cast<PointerType>(Operand->getType()); 869 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 870 const Type *RetTy = FTy->getReturnType(); 871 872 // If possible, print out the short form of the invoke instruction. We can 873 // only do this if the first argument is a pointer to a nonvararg function, 874 // and if the return type is not a pointer to a function. 875 // 876 if (!FTy->isVarArg() && 877 (!isa<PointerType>(RetTy) || 878 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 879 *Out << " "; printType(RetTy); 880 writeOperand(Operand, false); 881 } else { 882 writeOperand(Operand, true); 883 } 884 885 *Out << "("; 886 if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true); 887 for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) { 888 *Out << ","; 889 writeOperand(I.getOperand(op), true); 890 } 891 892 *Out << " )\n\t\t\tto"; 893 writeOperand(II->getNormalDest(), true); 894 *Out << " unwind"; 895 writeOperand(II->getUnwindDest(), true); 896 897 } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 898 *Out << " "; 899 printType(AI->getType()->getElementType()); 900 if (AI->isArrayAllocation()) { 901 *Out << ","; 902 writeOperand(AI->getArraySize(), true); 903 } 904 } else if (isa<CastInst>(I)) { 905 if (Operand) writeOperand(Operand, true); // Work with broken code 906 *Out << " to "; 907 printType(I.getType()); 908 } else if (isa<VAArgInst>(I)) { 909 if (Operand) writeOperand(Operand, true); // Work with broken code 910 *Out << ", "; 911 printType(I.getType()); 912 } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) { 913 if (Operand) writeOperand(Operand, true); // Work with broken code 914 *Out << ", "; 915 printType(VAN->getArgType()); 916 } else if (Operand) { // Print the normal way... 917 918 // PrintAllTypes - Instructions who have operands of all the same type 919 // omit the type from all but the first operand. If the instruction has 920 // different type operands (for example br), then they are all printed. 921 bool PrintAllTypes = false; 922 const Type *TheType = Operand->getType(); 923 924 // Shift Left & Right print both types even for Ubyte LHS, and select prints 925 // types even if all operands are bools. 926 if (isa<ShiftInst>(I) || isa<SelectInst>(I)) { 927 PrintAllTypes = true; 928 } else { 929 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 930 Operand = I.getOperand(i); 931 if (Operand->getType() != TheType) { 932 PrintAllTypes = true; // We have differing types! Print them all! 933 break; 934 } 935 } 936 } 937 938 if (!PrintAllTypes) { 939 *Out << " "; 940 printType(TheType); 941 } 942 943 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 944 if (i) *Out << ","; 945 writeOperand(I.getOperand(i), PrintAllTypes); 946 } 947 } 948 949 printInfoComment(I); 950 *Out << "\n"; 951} 952 953 954//===----------------------------------------------------------------------===// 955// External Interface declarations 956//===----------------------------------------------------------------------===// 957 958void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 959 SlotCalculator SlotTable(this, false); 960 AssemblyWriter W(o, SlotTable, this, AAW); 961 W.write(this); 962} 963 964void GlobalVariable::print(std::ostream &o) const { 965 SlotCalculator SlotTable(getParent(), false); 966 AssemblyWriter W(o, SlotTable, getParent(), 0); 967 W.write(this); 968} 969 970void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 971 SlotCalculator SlotTable(getParent(), false); 972 AssemblyWriter W(o, SlotTable, getParent(), AAW); 973 974 W.write(this); 975} 976 977void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 978 SlotCalculator SlotTable(getParent(), false); 979 AssemblyWriter W(o, SlotTable, 980 getParent() ? getParent()->getParent() : 0, AAW); 981 W.write(this); 982} 983 984void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 985 const Function *F = getParent() ? getParent()->getParent() : 0; 986 SlotCalculator SlotTable(F, false); 987 AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 988 989 W.write(this); 990} 991 992void Constant::print(std::ostream &o) const { 993 if (this == 0) { o << "<null> constant value\n"; return; } 994 995 // Handle CPR's special, because they have context information... 996 if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { 997 CPR->getValue()->print(o); // Print as a global value, with context info. 998 return; 999 } 1000 1001 o << " " << getType()->getDescription() << " "; 1002 1003 std::map<const Type *, std::string> TypeTable; 1004 WriteConstantInt(o, this, false, TypeTable, 0); 1005} 1006 1007void Type::print(std::ostream &o) const { 1008 if (this == 0) 1009 o << "<null Type>"; 1010 else 1011 o << getDescription(); 1012} 1013 1014void Argument::print(std::ostream &o) const { 1015 o << getType() << " " << getName(); 1016} 1017 1018void Value::dump() const { print(std::cerr); } 1019void Type::dump() const { print(std::cerr); } 1020 1021//===----------------------------------------------------------------------===// 1022// CachedWriter Class Implementation 1023//===----------------------------------------------------------------------===// 1024 1025void CachedWriter::setModule(const Module *M) { 1026 delete SC; delete AW; 1027 if (M) { 1028 SC = new SlotCalculator(M, false); 1029 AW = new AssemblyWriter(*Out, *SC, M, 0); 1030 } else { 1031 SC = 0; AW = 0; 1032 } 1033} 1034 1035CachedWriter::~CachedWriter() { 1036 delete AW; 1037 delete SC; 1038} 1039 1040CachedWriter &CachedWriter::operator<<(const Value *V) { 1041 assert(AW && SC && "CachedWriter does not have a current module!"); 1042 switch (V->getValueType()) { 1043 case Value::ConstantVal: 1044 case Value::ArgumentVal: AW->writeOperand(V, true, true); break; 1045 case Value::TypeVal: AW->write(cast<Type>(V)); break; 1046 case Value::InstructionVal: AW->write(cast<Instruction>(V)); break; 1047 case Value::BasicBlockVal: AW->write(cast<BasicBlock>(V)); break; 1048 case Value::FunctionVal: AW->write(cast<Function>(V)); break; 1049 case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break; 1050 default: *Out << "<unknown value type: " << V->getValueType() << ">"; break; 1051 } 1052 return *this; 1053} 1054 1055CachedWriter& CachedWriter::operator<<(const Type *X) { 1056 if (SymbolicTypes) { 1057 const Module *M = AW->getModule(); 1058 if (M) WriteTypeSymbolic(*Out, X, M); 1059 return *this; 1060 } else 1061 return *this << (const Value*)X; 1062} 1063 1064void CachedWriter::setStream(std::ostream &os) { 1065 Out = &os; 1066 if (AW) AW->setStream(os); 1067} 1068 1069// vim: sw=2 1070