AsmWriter.cpp revision 58d74910c6b82e622ecbb57d6644d48fec5a5c0f
1//===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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/Writer.h" 18#include "llvm/Assembly/PrintModulePass.h" 19#include "llvm/Assembly/AsmAnnotationWriter.h" 20#include "llvm/CallingConv.h" 21#include "llvm/Constants.h" 22#include "llvm/DerivedTypes.h" 23#include "llvm/InlineAsm.h" 24#include "llvm/Instruction.h" 25#include "llvm/Instructions.h" 26#include "llvm/Module.h" 27#include "llvm/ValueSymbolTable.h" 28#include "llvm/TypeSymbolTable.h" 29#include "llvm/ADT/StringExtras.h" 30#include "llvm/ADT/STLExtras.h" 31#include "llvm/Support/CFG.h" 32#include "llvm/Support/MathExtras.h" 33#include "llvm/Support/Streams.h" 34#include <algorithm> 35#include <cctype> 36using namespace llvm; 37 38namespace llvm { 39 40// Make virtual table appear in this compilation unit. 41AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 42 43/// 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 52 typedef std::map<const Value*,unsigned> ValueMap; 53 54/// @} 55/// @name Constructors 56/// @{ 57public: 58 /// @brief Construct from a module 59 explicit SlotMachine(const Module *M); 60 61 /// @brief Construct from a function, starting out in incorp state. 62 explicit SlotMachine(const Function *F); 63 64/// @} 65/// @name Accessors 66/// @{ 67public: 68 /// Return the slot number of the specified value in it's type 69 /// plane. If something is not in the SlotMachine, return -1. 70 int getLocalSlot(const Value *V); 71 int getGlobalSlot(const GlobalValue *V); 72 73/// @} 74/// @name Mutators 75/// @{ 76public: 77 /// If you'd like to deal with a function instead of just a module, use 78 /// this method to get its data into the SlotMachine. 79 void incorporateFunction(const Function *F) { 80 TheFunction = F; 81 FunctionProcessed = false; 82 } 83 84 /// After calling incorporateFunction, use this method to remove the 85 /// most recently incorporated function from the SlotMachine. This 86 /// will reset the state of the machine back to just the module contents. 87 void purgeFunction(); 88 89/// @} 90/// @name Implementation Details 91/// @{ 92private: 93 /// This function does the actual initialization. 94 inline void initialize(); 95 96 /// 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); 101 102 /// 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 106 /// Add all of the functions arguments, basic blocks, and instructions 107 void processFunction(); 108 109 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 118 const Module* TheModule; 119 120 /// @brief The function for which we are holding slot numbers 121 const Function* TheFunction; 122 bool FunctionProcessed; 123 124 /// @brief The TypePlanes map for the module level data 125 ValueMap mMap; 126 unsigned mNext; 127 128 /// @brief The TypePlanes map for the function level data 129 ValueMap fMap; 130 unsigned fNext; 131 132/// @} 133 134}; 135 136} // end namespace llvm 137 138char PrintModulePass::ID = 0; 139static RegisterPass<PrintModulePass> 140X("printm", "Print module to stderr"); 141char PrintFunctionPass::ID = 0; 142static RegisterPass<PrintFunctionPass> 143Y("print","Print function to stderr"); 144 145static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 146 std::map<const Type *, std::string> &TypeTable, 147 SlotMachine *Machine); 148 149static const Module *getModuleFromVal(const Value *V) { 150 if (const Argument *MA = dyn_cast<Argument>(V)) 151 return MA->getParent() ? MA->getParent()->getParent() : 0; 152 else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 153 return BB->getParent() ? BB->getParent()->getParent() : 0; 154 else if (const Instruction *I = dyn_cast<Instruction>(V)) { 155 const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 156 return M ? M->getParent() : 0; 157 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 158 return GV->getParent(); 159 return 0; 160} 161 162static SlotMachine *createSlotMachine(const Value *V) { 163 if (const Argument *FA = dyn_cast<Argument>(V)) { 164 return new SlotMachine(FA->getParent()); 165 } else if (const Instruction *I = dyn_cast<Instruction>(V)) { 166 return new SlotMachine(I->getParent()->getParent()); 167 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { 168 return new SlotMachine(BB->getParent()); 169 } else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)){ 170 return new SlotMachine(GV->getParent()); 171 } else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)){ 172 return new SlotMachine(GA->getParent()); 173 } else if (const Function *Func = dyn_cast<Function>(V)) { 174 return new SlotMachine(Func); 175 } 176 return 0; 177} 178 179/// NameNeedsQuotes - Return true if the specified llvm name should be wrapped 180/// with ""'s. 181static std::string QuoteNameIfNeeded(const std::string &Name) { 182 std::string result; 183 bool needsQuotes = Name[0] >= '0' && Name[0] <= '9'; 184 // Scan the name to see if it needs quotes and to replace funky chars with 185 // their octal equivalent. 186 for (unsigned i = 0, e = Name.size(); i != e; ++i) { 187 char C = Name[i]; 188 assert(C != '"' && "Illegal character in LLVM value name!"); 189 if (isalnum(C) || C == '-' || C == '.' || C == '_') 190 result += C; 191 else if (C == '\\') { 192 needsQuotes = true; 193 result += "\\\\"; 194 } else if (isprint(C)) { 195 needsQuotes = true; 196 result += C; 197 } else { 198 needsQuotes = true; 199 result += "\\"; 200 char hex1 = (C >> 4) & 0x0F; 201 if (hex1 < 10) 202 result += hex1 + '0'; 203 else 204 result += hex1 - 10 + 'A'; 205 char hex2 = C & 0x0F; 206 if (hex2 < 10) 207 result += hex2 + '0'; 208 else 209 result += hex2 - 10 + 'A'; 210 } 211 } 212 if (needsQuotes) { 213 result.insert(0,"\""); 214 result += '"'; 215 } 216 return result; 217} 218 219enum PrefixType { 220 GlobalPrefix, 221 LabelPrefix, 222 LocalPrefix 223}; 224 225/// getLLVMName - Turn the specified string into an 'LLVM name', which is either 226/// prefixed with % (if the string only contains simple characters) or is 227/// surrounded with ""'s (if it has special chars in it). 228static std::string getLLVMName(const std::string &Name, PrefixType Prefix) { 229 assert(!Name.empty() && "Cannot get empty name!"); 230 switch (Prefix) { 231 default: assert(0 && "Bad prefix!"); 232 case GlobalPrefix: return '@' + QuoteNameIfNeeded(Name); 233 case LabelPrefix: return QuoteNameIfNeeded(Name); 234 case LocalPrefix: return '%' + QuoteNameIfNeeded(Name); 235 } 236} 237 238 239/// fillTypeNameTable - If the module has a symbol table, take all global types 240/// and stuff their names into the TypeNames map. 241/// 242static void fillTypeNameTable(const Module *M, 243 std::map<const Type *, std::string> &TypeNames) { 244 if (!M) return; 245 const TypeSymbolTable &ST = M->getTypeSymbolTable(); 246 TypeSymbolTable::const_iterator TI = ST.begin(); 247 for (; TI != ST.end(); ++TI) { 248 // As a heuristic, don't insert pointer to primitive types, because 249 // they are used too often to have a single useful name. 250 // 251 const Type *Ty = cast<Type>(TI->second); 252 if (!isa<PointerType>(Ty) || 253 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() || 254 !cast<PointerType>(Ty)->getElementType()->isInteger() || 255 isa<OpaqueType>(cast<PointerType>(Ty)->getElementType())) 256 TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first, LocalPrefix))); 257 } 258} 259 260 261 262static void calcTypeName(const Type *Ty, 263 std::vector<const Type *> &TypeStack, 264 std::map<const Type *, std::string> &TypeNames, 265 std::string & Result){ 266 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) { 267 Result += Ty->getDescription(); // Base case 268 return; 269 } 270 271 // Check to see if the type is named. 272 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 273 if (I != TypeNames.end()) { 274 Result += I->second; 275 return; 276 } 277 278 if (isa<OpaqueType>(Ty)) { 279 Result += "opaque"; 280 return; 281 } 282 283 // Check to see if the Type is already on the stack... 284 unsigned Slot = 0, CurSize = TypeStack.size(); 285 while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type 286 287 // This is another base case for the recursion. In this case, we know 288 // that we have looped back to a type that we have previously visited. 289 // Generate the appropriate upreference to handle this. 290 if (Slot < CurSize) { 291 Result += "\\" + utostr(CurSize-Slot); // Here's the upreference 292 return; 293 } 294 295 TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. 296 297 switch (Ty->getTypeID()) { 298 case Type::IntegerTyID: { 299 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth(); 300 Result += "i" + utostr(BitWidth); 301 break; 302 } 303 case Type::FunctionTyID: { 304 const FunctionType *FTy = cast<FunctionType>(Ty); 305 calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); 306 Result += " ("; 307 for (FunctionType::param_iterator I = FTy->param_begin(), 308 E = FTy->param_end(); I != E; ++I) { 309 if (I != FTy->param_begin()) 310 Result += ", "; 311 calcTypeName(*I, TypeStack, TypeNames, Result); 312 } 313 if (FTy->isVarArg()) { 314 if (FTy->getNumParams()) Result += ", "; 315 Result += "..."; 316 } 317 Result += ")"; 318 break; 319 } 320 case Type::StructTyID: { 321 const StructType *STy = cast<StructType>(Ty); 322 if (STy->isPacked()) 323 Result += '<'; 324 Result += "{ "; 325 for (StructType::element_iterator I = STy->element_begin(), 326 E = STy->element_end(); I != E; ++I) { 327 if (I != STy->element_begin()) 328 Result += ", "; 329 calcTypeName(*I, TypeStack, TypeNames, Result); 330 } 331 Result += " }"; 332 if (STy->isPacked()) 333 Result += '>'; 334 break; 335 } 336 case Type::PointerTyID: { 337 const PointerType *PTy = cast<PointerType>(Ty); 338 calcTypeName(PTy->getElementType(), 339 TypeStack, TypeNames, Result); 340 if (unsigned AddressSpace = PTy->getAddressSpace()) 341 Result += " addrspace(" + utostr(AddressSpace) + ")"; 342 Result += "*"; 343 break; 344 } 345 case Type::ArrayTyID: { 346 const ArrayType *ATy = cast<ArrayType>(Ty); 347 Result += "[" + utostr(ATy->getNumElements()) + " x "; 348 calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); 349 Result += "]"; 350 break; 351 } 352 case Type::VectorTyID: { 353 const VectorType *PTy = cast<VectorType>(Ty); 354 Result += "<" + utostr(PTy->getNumElements()) + " x "; 355 calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); 356 Result += ">"; 357 break; 358 } 359 case Type::OpaqueTyID: 360 Result += "opaque"; 361 break; 362 default: 363 Result += "<unrecognized-type>"; 364 break; 365 } 366 367 TypeStack.pop_back(); // Remove self from stack... 368} 369 370 371/// printTypeInt - The internal guts of printing out a type that has a 372/// potentially named portion. 373/// 374static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, 375 std::map<const Type *, std::string> &TypeNames) { 376 // Primitive types always print out their description, regardless of whether 377 // they have been named or not. 378 // 379 if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) 380 return Out << Ty->getDescription(); 381 382 // Check to see if the type is named. 383 std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty); 384 if (I != TypeNames.end()) return Out << I->second; 385 386 // Otherwise we have a type that has not been named but is a derived type. 387 // Carefully recurse the type hierarchy to print out any contained symbolic 388 // names. 389 // 390 std::vector<const Type *> TypeStack; 391 std::string TypeName; 392 calcTypeName(Ty, TypeStack, TypeNames, TypeName); 393 TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use 394 return (Out << TypeName); 395} 396 397 398/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic 399/// type, iff there is an entry in the modules symbol table for the specified 400/// type or one of it's component types. This is slower than a simple x << Type 401/// 402std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, 403 const Module *M) { 404 Out << ' '; 405 406 // If they want us to print out a type, but there is no context, we can't 407 // print it symbolically. 408 if (!M) 409 return Out << Ty->getDescription(); 410 411 std::map<const Type *, std::string> TypeNames; 412 fillTypeNameTable(M, TypeNames); 413 return printTypeInt(Out, Ty, TypeNames); 414} 415 416// PrintEscapedString - Print each character of the specified string, escaping 417// it if it is not printable or if it is an escape char. 418static void PrintEscapedString(const std::string &Str, std::ostream &Out) { 419 for (unsigned i = 0, e = Str.size(); i != e; ++i) { 420 unsigned char C = Str[i]; 421 if (isprint(C) && C != '"' && C != '\\') { 422 Out << C; 423 } else { 424 Out << '\\' 425 << (char) ((C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A')) 426 << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A')); 427 } 428 } 429} 430 431static const char *getPredicateText(unsigned predicate) { 432 const char * pred = "unknown"; 433 switch (predicate) { 434 case FCmpInst::FCMP_FALSE: pred = "false"; break; 435 case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 436 case FCmpInst::FCMP_OGT: pred = "ogt"; break; 437 case FCmpInst::FCMP_OGE: pred = "oge"; break; 438 case FCmpInst::FCMP_OLT: pred = "olt"; break; 439 case FCmpInst::FCMP_OLE: pred = "ole"; break; 440 case FCmpInst::FCMP_ONE: pred = "one"; break; 441 case FCmpInst::FCMP_ORD: pred = "ord"; break; 442 case FCmpInst::FCMP_UNO: pred = "uno"; break; 443 case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 444 case FCmpInst::FCMP_UGT: pred = "ugt"; break; 445 case FCmpInst::FCMP_UGE: pred = "uge"; break; 446 case FCmpInst::FCMP_ULT: pred = "ult"; break; 447 case FCmpInst::FCMP_ULE: pred = "ule"; break; 448 case FCmpInst::FCMP_UNE: pred = "une"; break; 449 case FCmpInst::FCMP_TRUE: pred = "true"; break; 450 case ICmpInst::ICMP_EQ: pred = "eq"; break; 451 case ICmpInst::ICMP_NE: pred = "ne"; break; 452 case ICmpInst::ICMP_SGT: pred = "sgt"; break; 453 case ICmpInst::ICMP_SGE: pred = "sge"; break; 454 case ICmpInst::ICMP_SLT: pred = "slt"; break; 455 case ICmpInst::ICMP_SLE: pred = "sle"; break; 456 case ICmpInst::ICMP_UGT: pred = "ugt"; break; 457 case ICmpInst::ICMP_UGE: pred = "uge"; break; 458 case ICmpInst::ICMP_ULT: pred = "ult"; break; 459 case ICmpInst::ICMP_ULE: pred = "ule"; break; 460 } 461 return pred; 462} 463 464/// @brief Internal constant writer. 465static void WriteConstantInt(std::ostream &Out, const Constant *CV, 466 std::map<const Type *, std::string> &TypeTable, 467 SlotMachine *Machine) { 468 const int IndentSize = 4; 469 static std::string Indent = "\n"; 470 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 471 if (CI->getType() == Type::Int1Ty) 472 Out << (CI->getZExtValue() ? "true" : "false"); 473 else 474 Out << CI->getValue().toStringSigned(10); 475 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 476 if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble || 477 &CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle) { 478 // We would like to output the FP constant value in exponential notation, 479 // but we cannot do this if doing so will lose precision. Check here to 480 // make sure that we only output it in exponential format if we can parse 481 // the value back and get the same value. 482 // 483 bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble; 484 double Val = (isDouble) ? CFP->getValueAPF().convertToDouble() : 485 CFP->getValueAPF().convertToFloat(); 486 std::string StrVal = ftostr(CFP->getValueAPF()); 487 488 // Check to make sure that the stringized number is not some string like 489 // "Inf" or NaN, that atof will accept, but the lexer will not. Check 490 // that the string matches the "[-+]?[0-9]" regex. 491 // 492 if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 493 ((StrVal[0] == '-' || StrVal[0] == '+') && 494 (StrVal[1] >= '0' && StrVal[1] <= '9'))) { 495 // Reparse stringized version! 496 if (atof(StrVal.c_str()) == Val) { 497 Out << StrVal; 498 return; 499 } 500 } 501 // Otherwise we could not reparse it to exactly the same value, so we must 502 // output the string in hexadecimal format! 503 assert(sizeof(double) == sizeof(uint64_t) && 504 "assuming that double is 64 bits!"); 505 Out << "0x" << utohexstr(DoubleToBits(Val)); 506 } else { 507 // Some form of long double. These appear as a magic letter identifying 508 // the type, then a fixed number of hex digits. 509 Out << "0x"; 510 if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) 511 Out << 'K'; 512 else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) 513 Out << 'L'; 514 else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) 515 Out << 'M'; 516 else 517 assert(0 && "Unsupported floating point type"); 518 // api needed to prevent premature destruction 519 APInt api = CFP->getValueAPF().convertToAPInt(); 520 const uint64_t* p = api.getRawData(); 521 uint64_t word = *p; 522 int shiftcount=60; 523 int width = api.getBitWidth(); 524 for (int j=0; j<width; j+=4, shiftcount-=4) { 525 unsigned int nibble = (word>>shiftcount) & 15; 526 if (nibble < 10) 527 Out << (unsigned char)(nibble + '0'); 528 else 529 Out << (unsigned char)(nibble - 10 + 'A'); 530 if (shiftcount == 0) { 531 word = *(++p); 532 shiftcount = 64; 533 if (width-j-4 < 64) 534 shiftcount = width-j-4; 535 } 536 } 537 } 538 } else if (isa<ConstantAggregateZero>(CV)) { 539 Out << "zeroinitializer"; 540 } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 541 // As a special case, print the array as a string if it is an array of 542 // ubytes or an array of sbytes with positive values. 543 // 544 const Type *ETy = CA->getType()->getElementType(); 545 if (CA->isString()) { 546 Out << "c\""; 547 PrintEscapedString(CA->getAsString(), Out); 548 Out << "\""; 549 550 } else { // Cannot output in string format... 551 Out << '['; 552 if (CA->getNumOperands()) { 553 Out << ' '; 554 printTypeInt(Out, ETy, TypeTable); 555 WriteAsOperandInternal(Out, CA->getOperand(0), 556 TypeTable, Machine); 557 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 558 Out << ", "; 559 printTypeInt(Out, ETy, TypeTable); 560 WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine); 561 } 562 } 563 Out << " ]"; 564 } 565 } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 566 if (CS->getType()->isPacked()) 567 Out << '<'; 568 Out << '{'; 569 unsigned N = CS->getNumOperands(); 570 if (N) { 571 if (N > 2) { 572 Indent += std::string(IndentSize, ' '); 573 Out << Indent; 574 } else { 575 Out << ' '; 576 } 577 printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); 578 579 WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine); 580 581 for (unsigned i = 1; i < N; i++) { 582 Out << ", "; 583 if (N > 2) Out << Indent; 584 printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); 585 586 WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine); 587 } 588 if (N > 2) Indent.resize(Indent.size() - IndentSize); 589 } 590 591 Out << " }"; 592 if (CS->getType()->isPacked()) 593 Out << '>'; 594 } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) { 595 const Type *ETy = CP->getType()->getElementType(); 596 assert(CP->getNumOperands() > 0 && 597 "Number of operands for a PackedConst must be > 0"); 598 Out << '<'; 599 Out << ' '; 600 printTypeInt(Out, ETy, TypeTable); 601 WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine); 602 for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { 603 Out << ", "; 604 printTypeInt(Out, ETy, TypeTable); 605 WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine); 606 } 607 Out << " >"; 608 } else if (isa<ConstantPointerNull>(CV)) { 609 Out << "null"; 610 611 } else if (isa<UndefValue>(CV)) { 612 Out << "undef"; 613 614 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 615 Out << CE->getOpcodeName(); 616 if (CE->isCompare()) 617 Out << " " << getPredicateText(CE->getPredicate()); 618 Out << " ("; 619 620 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 621 printTypeInt(Out, (*OI)->getType(), TypeTable); 622 WriteAsOperandInternal(Out, *OI, TypeTable, Machine); 623 if (OI+1 != CE->op_end()) 624 Out << ", "; 625 } 626 627 if (CE->isCast()) { 628 Out << " to "; 629 printTypeInt(Out, CE->getType(), TypeTable); 630 } 631 632 Out << ')'; 633 634 } else { 635 Out << "<placeholder or erroneous Constant>"; 636 } 637} 638 639 640/// WriteAsOperand - Write the name of the specified value out to the specified 641/// ostream. This can be useful when you just want to print int %reg126, not 642/// the whole instruction that generated it. 643/// 644static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 645 std::map<const Type*, std::string> &TypeTable, 646 SlotMachine *Machine) { 647 Out << ' '; 648 if (V->hasName()) 649 Out << getLLVMName(V->getName(), 650 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix); 651 else { 652 const Constant *CV = dyn_cast<Constant>(V); 653 if (CV && !isa<GlobalValue>(CV)) { 654 WriteConstantInt(Out, CV, TypeTable, Machine); 655 } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 656 Out << "asm "; 657 if (IA->hasSideEffects()) 658 Out << "sideeffect "; 659 Out << '"'; 660 PrintEscapedString(IA->getAsmString(), Out); 661 Out << "\", \""; 662 PrintEscapedString(IA->getConstraintString(), Out); 663 Out << '"'; 664 } else { 665 char Prefix = '%'; 666 int Slot; 667 if (Machine) { 668 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 669 Slot = Machine->getGlobalSlot(GV); 670 Prefix = '@'; 671 } else { 672 Slot = Machine->getLocalSlot(V); 673 } 674 } else { 675 Machine = createSlotMachine(V); 676 if (Machine) { 677 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 678 Slot = Machine->getGlobalSlot(GV); 679 Prefix = '@'; 680 } else { 681 Slot = Machine->getLocalSlot(V); 682 } 683 } else { 684 Slot = -1; 685 } 686 delete Machine; 687 } 688 if (Slot != -1) 689 Out << Prefix << Slot; 690 else 691 Out << "<badref>"; 692 } 693 } 694} 695 696/// WriteAsOperand - Write the name of the specified value out to the specified 697/// ostream. This can be useful when you just want to print int %reg126, not 698/// the whole instruction that generated it. 699/// 700std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V, 701 bool PrintType, const Module *Context) { 702 std::map<const Type *, std::string> TypeNames; 703 if (Context == 0) Context = getModuleFromVal(V); 704 705 if (Context) 706 fillTypeNameTable(Context, TypeNames); 707 708 if (PrintType) 709 printTypeInt(Out, V->getType(), TypeNames); 710 711 WriteAsOperandInternal(Out, V, TypeNames, 0); 712 return Out; 713} 714 715 716namespace llvm { 717 718class AssemblyWriter { 719 std::ostream &Out; 720 SlotMachine &Machine; 721 const Module *TheModule; 722 std::map<const Type *, std::string> TypeNames; 723 AssemblyAnnotationWriter *AnnotationWriter; 724public: 725 inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M, 726 AssemblyAnnotationWriter *AAW) 727 : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 728 729 // If the module has a symbol table, take all global types and stuff their 730 // names into the TypeNames map. 731 // 732 fillTypeNameTable(M, TypeNames); 733 } 734 735 inline void write(const Module *M) { printModule(M); } 736 inline void write(const GlobalVariable *G) { printGlobal(G); } 737 inline void write(const GlobalAlias *G) { printAlias(G); } 738 inline void write(const Function *F) { printFunction(F); } 739 inline void write(const BasicBlock *BB) { printBasicBlock(BB); } 740 inline void write(const Instruction *I) { printInstruction(*I); } 741 inline void write(const Type *Ty) { printType(Ty); } 742 743 void writeOperand(const Value *Op, bool PrintType); 744 void writeParamOperand(const Value *Operand, ParameterAttributes Attrs); 745 746 const Module* getModule() { return TheModule; } 747 748private: 749 void printModule(const Module *M); 750 void printTypeSymbolTable(const TypeSymbolTable &ST); 751 void printGlobal(const GlobalVariable *GV); 752 void printAlias(const GlobalAlias *GV); 753 void printFunction(const Function *F); 754 void printArgument(const Argument *FA, ParameterAttributes Attrs); 755 void printBasicBlock(const BasicBlock *BB); 756 void printInstruction(const Instruction &I); 757 758 // printType - Go to extreme measures to attempt to print out a short, 759 // symbolic version of a type name. 760 // 761 std::ostream &printType(const Type *Ty) { 762 return printTypeInt(Out, Ty, TypeNames); 763 } 764 765 // printTypeAtLeastOneLevel - Print out one level of the possibly complex type 766 // without considering any symbolic types that we may have equal to it. 767 // 768 std::ostream &printTypeAtLeastOneLevel(const Type *Ty); 769 770 // printInfoComment - Print a little comment after the instruction indicating 771 // which slot it occupies. 772 void printInfoComment(const Value &V); 773}; 774} // end of llvm namespace 775 776/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type 777/// without considering any symbolic types that we may have equal to it. 778/// 779std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { 780 if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 781 Out << "i" << utostr(ITy->getBitWidth()); 782 else if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) { 783 printType(FTy->getReturnType()); 784 Out << " ("; 785 for (FunctionType::param_iterator I = FTy->param_begin(), 786 E = FTy->param_end(); I != E; ++I) { 787 if (I != FTy->param_begin()) 788 Out << ", "; 789 printType(*I); 790 } 791 if (FTy->isVarArg()) { 792 if (FTy->getNumParams()) Out << ", "; 793 Out << "..."; 794 } 795 Out << ')'; 796 } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 797 if (STy->isPacked()) 798 Out << '<'; 799 Out << "{ "; 800 for (StructType::element_iterator I = STy->element_begin(), 801 E = STy->element_end(); I != E; ++I) { 802 if (I != STy->element_begin()) 803 Out << ", "; 804 printType(*I); 805 } 806 Out << " }"; 807 if (STy->isPacked()) 808 Out << '>'; 809 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) { 810 printType(PTy->getElementType()); 811 if (unsigned AddressSpace = PTy->getAddressSpace()) 812 Out << " addrspace(" << AddressSpace << ")"; 813 Out << '*'; 814 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 815 Out << '[' << ATy->getNumElements() << " x "; 816 printType(ATy->getElementType()) << ']'; 817 } else if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) { 818 Out << '<' << PTy->getNumElements() << " x "; 819 printType(PTy->getElementType()) << '>'; 820 } 821 else if (isa<OpaqueType>(Ty)) { 822 Out << "opaque"; 823 } else { 824 if (!Ty->isPrimitiveType()) 825 Out << "<unknown derived type>"; 826 printType(Ty); 827 } 828 return Out; 829} 830 831 832void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 833 if (Operand == 0) { 834 Out << "<null operand!>"; 835 } else { 836 if (PrintType) { Out << ' '; printType(Operand->getType()); } 837 WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 838 } 839} 840 841void AssemblyWriter::writeParamOperand(const Value *Operand, 842 ParameterAttributes Attrs) { 843 if (Operand == 0) { 844 Out << "<null operand!>"; 845 } else { 846 Out << ' '; 847 // Print the type 848 printType(Operand->getType()); 849 // Print parameter attributes list 850 if (Attrs != ParamAttr::None) 851 Out << ' ' << ParamAttr::getAsString(Attrs); 852 // Print the operand 853 WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); 854 } 855} 856 857void AssemblyWriter::printModule(const Module *M) { 858 if (!M->getModuleIdentifier().empty() && 859 // Don't print the ID if it will start a new line (which would 860 // require a comment char before it). 861 M->getModuleIdentifier().find('\n') == std::string::npos) 862 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 863 864 if (!M->getDataLayout().empty()) 865 Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 866 if (!M->getTargetTriple().empty()) 867 Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 868 869 if (!M->getModuleInlineAsm().empty()) { 870 // Split the string into lines, to make it easier to read the .ll file. 871 std::string Asm = M->getModuleInlineAsm(); 872 size_t CurPos = 0; 873 size_t NewLine = Asm.find_first_of('\n', CurPos); 874 while (NewLine != std::string::npos) { 875 // We found a newline, print the portion of the asm string from the 876 // last newline up to this newline. 877 Out << "module asm \""; 878 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 879 Out); 880 Out << "\"\n"; 881 CurPos = NewLine+1; 882 NewLine = Asm.find_first_of('\n', CurPos); 883 } 884 Out << "module asm \""; 885 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); 886 Out << "\"\n"; 887 } 888 889 // Loop over the dependent libraries and emit them. 890 Module::lib_iterator LI = M->lib_begin(); 891 Module::lib_iterator LE = M->lib_end(); 892 if (LI != LE) { 893 Out << "deplibs = [ "; 894 while (LI != LE) { 895 Out << '"' << *LI << '"'; 896 ++LI; 897 if (LI != LE) 898 Out << ", "; 899 } 900 Out << " ]\n"; 901 } 902 903 // Loop over the symbol table, emitting all named constants. 904 printTypeSymbolTable(M->getTypeSymbolTable()); 905 906 for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 907 I != E; ++I) 908 printGlobal(I); 909 910 // Output all aliases. 911 if (!M->alias_empty()) Out << "\n"; 912 for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 913 I != E; ++I) 914 printAlias(I); 915 916 // Output all of the functions. 917 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 918 printFunction(I); 919} 920 921void AssemblyWriter::printGlobal(const GlobalVariable *GV) { 922 if (GV->hasName()) Out << getLLVMName(GV->getName(), GlobalPrefix) << " = "; 923 924 if (!GV->hasInitializer()) { 925 switch (GV->getLinkage()) { 926 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 927 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 928 default: Out << "external "; break; 929 } 930 } else { 931 switch (GV->getLinkage()) { 932 case GlobalValue::InternalLinkage: Out << "internal "; break; 933 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 934 case GlobalValue::WeakLinkage: Out << "weak "; break; 935 case GlobalValue::AppendingLinkage: Out << "appending "; break; 936 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 937 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 938 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 939 case GlobalValue::ExternalLinkage: break; 940 case GlobalValue::GhostLinkage: 941 cerr << "GhostLinkage not allowed in AsmWriter!\n"; 942 abort(); 943 } 944 switch (GV->getVisibility()) { 945 default: assert(0 && "Invalid visibility style!"); 946 case GlobalValue::DefaultVisibility: break; 947 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 948 case GlobalValue::ProtectedVisibility: Out << "protected "; break; 949 } 950 } 951 952 if (GV->isThreadLocal()) Out << "thread_local "; 953 Out << (GV->isConstant() ? "constant " : "global "); 954 printType(GV->getType()->getElementType()); 955 956 if (GV->hasInitializer()) { 957 Constant* C = cast<Constant>(GV->getInitializer()); 958 assert(C && "GlobalVar initializer isn't constant?"); 959 writeOperand(GV->getInitializer(), false); 960 } 961 962 if (unsigned AddressSpace = GV->getType()->getAddressSpace()) 963 Out << " addrspace(" << AddressSpace << ") "; 964 965 if (GV->hasSection()) 966 Out << ", section \"" << GV->getSection() << '"'; 967 if (GV->getAlignment()) 968 Out << ", align " << GV->getAlignment(); 969 970 printInfoComment(*GV); 971 Out << "\n"; 972} 973 974void AssemblyWriter::printAlias(const GlobalAlias *GA) { 975 Out << getLLVMName(GA->getName(), GlobalPrefix) << " = "; 976 switch (GA->getVisibility()) { 977 default: assert(0 && "Invalid visibility style!"); 978 case GlobalValue::DefaultVisibility: break; 979 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 980 case GlobalValue::ProtectedVisibility: Out << "protected "; break; 981 } 982 983 Out << "alias "; 984 985 switch (GA->getLinkage()) { 986 case GlobalValue::WeakLinkage: Out << "weak "; break; 987 case GlobalValue::InternalLinkage: Out << "internal "; break; 988 case GlobalValue::ExternalLinkage: break; 989 default: 990 assert(0 && "Invalid alias linkage"); 991 } 992 993 const Constant *Aliasee = GA->getAliasee(); 994 995 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Aliasee)) { 996 printType(GV->getType()); 997 Out << " " << getLLVMName(GV->getName(), GlobalPrefix); 998 } else if (const Function *F = dyn_cast<Function>(Aliasee)) { 999 printType(F->getFunctionType()); 1000 Out << "* "; 1001 1002 if (!F->getName().empty()) 1003 Out << getLLVMName(F->getName(), GlobalPrefix); 1004 else 1005 Out << "@\"\""; 1006 } else { 1007 const ConstantExpr *CE = 0; 1008 if ((CE = dyn_cast<ConstantExpr>(Aliasee)) && 1009 (CE->getOpcode() == Instruction::BitCast)) { 1010 writeOperand(CE, false); 1011 } else 1012 assert(0 && "Unsupported aliasee"); 1013 } 1014 1015 printInfoComment(*GA); 1016 Out << "\n"; 1017} 1018 1019void AssemblyWriter::printTypeSymbolTable(const TypeSymbolTable &ST) { 1020 // Print the types. 1021 for (TypeSymbolTable::const_iterator TI = ST.begin(), TE = ST.end(); 1022 TI != TE; ++TI) { 1023 Out << "\t" << getLLVMName(TI->first, LocalPrefix) << " = type "; 1024 1025 // Make sure we print out at least one level of the type structure, so 1026 // that we do not get %FILE = type %FILE 1027 // 1028 printTypeAtLeastOneLevel(TI->second) << "\n"; 1029 } 1030} 1031 1032/// printFunction - Print all aspects of a function. 1033/// 1034void AssemblyWriter::printFunction(const Function *F) { 1035 // Print out the return type and name... 1036 Out << "\n"; 1037 1038 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 1039 1040 if (F->isDeclaration()) 1041 Out << "declare "; 1042 else 1043 Out << "define "; 1044 1045 switch (F->getLinkage()) { 1046 case GlobalValue::InternalLinkage: Out << "internal "; break; 1047 case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; 1048 case GlobalValue::WeakLinkage: Out << "weak "; break; 1049 case GlobalValue::AppendingLinkage: Out << "appending "; break; 1050 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 1051 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 1052 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 1053 case GlobalValue::ExternalLinkage: break; 1054 case GlobalValue::GhostLinkage: 1055 cerr << "GhostLinkage not allowed in AsmWriter!\n"; 1056 abort(); 1057 } 1058 switch (F->getVisibility()) { 1059 default: assert(0 && "Invalid visibility style!"); 1060 case GlobalValue::DefaultVisibility: break; 1061 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 1062 case GlobalValue::ProtectedVisibility: Out << "protected "; break; 1063 } 1064 1065 // Print the calling convention. 1066 switch (F->getCallingConv()) { 1067 case CallingConv::C: break; // default 1068 case CallingConv::Fast: Out << "fastcc "; break; 1069 case CallingConv::Cold: Out << "coldcc "; break; 1070 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1071 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1072 default: Out << "cc" << F->getCallingConv() << " "; break; 1073 } 1074 1075 const FunctionType *FT = F->getFunctionType(); 1076 const PAListPtr &Attrs = F->getParamAttrs(); 1077 printType(F->getReturnType()) << ' '; 1078 if (!F->getName().empty()) 1079 Out << getLLVMName(F->getName(), GlobalPrefix); 1080 else 1081 Out << "@\"\""; 1082 Out << '('; 1083 Machine.incorporateFunction(F); 1084 1085 // Loop over the arguments, printing them... 1086 1087 unsigned Idx = 1; 1088 if (!F->isDeclaration()) { 1089 // If this isn't a declaration, print the argument names as well. 1090 for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 1091 I != E; ++I) { 1092 // Insert commas as we go... the first arg doesn't get a comma 1093 if (I != F->arg_begin()) Out << ", "; 1094 printArgument(I, Attrs.getParamAttrs(Idx)); 1095 Idx++; 1096 } 1097 } else { 1098 // Otherwise, print the types from the function type. 1099 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 1100 // Insert commas as we go... the first arg doesn't get a comma 1101 if (i) Out << ", "; 1102 1103 // Output type... 1104 printType(FT->getParamType(i)); 1105 1106 ParameterAttributes ArgAttrs = Attrs.getParamAttrs(i+1); 1107 if (ArgAttrs != ParamAttr::None) 1108 Out << ' ' << ParamAttr::getAsString(ArgAttrs); 1109 } 1110 } 1111 1112 // Finish printing arguments... 1113 if (FT->isVarArg()) { 1114 if (FT->getNumParams()) Out << ", "; 1115 Out << "..."; // Output varargs portion of signature! 1116 } 1117 Out << ')'; 1118 ParameterAttributes RetAttrs = Attrs.getParamAttrs(0); 1119 if (RetAttrs != ParamAttr::None) 1120 Out << ' ' << ParamAttr::getAsString(Attrs.getParamAttrs(0)); 1121 if (F->hasSection()) 1122 Out << " section \"" << F->getSection() << '"'; 1123 if (F->getAlignment()) 1124 Out << " align " << F->getAlignment(); 1125 if (F->hasCollector()) 1126 Out << " gc \"" << F->getCollector() << '"'; 1127 1128 if (F->isDeclaration()) { 1129 Out << "\n"; 1130 } else { 1131 Out << " {\n"; 1132 1133 // Output all of its basic blocks... for the function 1134 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 1135 printBasicBlock(I); 1136 1137 Out << "}\n"; 1138 } 1139 1140 Machine.purgeFunction(); 1141} 1142 1143/// printArgument - This member is called for every argument that is passed into 1144/// the function. Simply print it out 1145/// 1146void AssemblyWriter::printArgument(const Argument *Arg, 1147 ParameterAttributes Attrs) { 1148 // Output type... 1149 printType(Arg->getType()); 1150 1151 // Output parameter attributes list 1152 if (Attrs != ParamAttr::None) 1153 Out << ' ' << ParamAttr::getAsString(Attrs); 1154 1155 // Output name, if available... 1156 if (Arg->hasName()) 1157 Out << ' ' << getLLVMName(Arg->getName(), LocalPrefix); 1158} 1159 1160/// printBasicBlock - This member is called for each basic block in a method. 1161/// 1162void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1163 if (BB->hasName()) // Print out the label if it exists... 1164 Out << getLLVMName(BB->getName(), LabelPrefix) << ':'; 1165 1166 if (const BasicBlock* unwindDest = BB->getUnwindDest()) { 1167 if (BB->hasName()) 1168 Out << ' '; 1169 1170 Out << "unwinds to"; 1171 writeOperand(unwindDest, false); 1172 } 1173 1174 if (!BB->hasName() && !BB->use_empty()) { // Don't print block # of no uses... 1175 Out << "; <label>:"; 1176 int Slot = Machine.getLocalSlot(BB); 1177 if (Slot != -1) 1178 Out << Slot; 1179 else 1180 Out << "<badref>"; 1181 } 1182 1183 if (BB->getParent() == 0) 1184 Out << "\t\t; Error: Block without parent!"; 1185 else { 1186 if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block? 1187 // Output predecessors for the block... 1188 Out << "\t\t;"; 1189 pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB); 1190 1191 if (PI == PE) { 1192 Out << " No predecessors!"; 1193 } else { 1194 Out << " preds ="; 1195 writeOperand(*PI, false); 1196 for (++PI; PI != PE; ++PI) { 1197 Out << ','; 1198 writeOperand(*PI, false); 1199 } 1200 } 1201 } 1202 } 1203 1204 if (BB->hasName() || !BB->use_empty() || BB->getUnwindDest() || 1205 BB != &BB->getParent()->getEntryBlock()) 1206 Out << "\n"; 1207 1208 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 1209 1210 // Output all of the instructions in the basic block... 1211 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1212 printInstruction(*I); 1213 1214 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1215} 1216 1217 1218/// printInfoComment - Print a little comment after the instruction indicating 1219/// which slot it occupies. 1220/// 1221void AssemblyWriter::printInfoComment(const Value &V) { 1222 if (V.getType() != Type::VoidTy) { 1223 Out << "\t\t; <"; 1224 printType(V.getType()) << '>'; 1225 1226 if (!V.hasName()) { 1227 int SlotNum; 1228 if (const GlobalValue *GV = dyn_cast<GlobalValue>(&V)) 1229 SlotNum = Machine.getGlobalSlot(GV); 1230 else 1231 SlotNum = Machine.getLocalSlot(&V); 1232 if (SlotNum == -1) 1233 Out << ":<badref>"; 1234 else 1235 Out << ':' << SlotNum; // Print out the def slot taken. 1236 } 1237 Out << " [#uses=" << V.getNumUses() << ']'; // Output # uses 1238 } 1239} 1240 1241// This member is called for each Instruction in a function.. 1242void AssemblyWriter::printInstruction(const Instruction &I) { 1243 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 1244 1245 Out << "\t"; 1246 1247 // Print out name if it exists... 1248 if (I.hasName()) 1249 Out << getLLVMName(I.getName(), LocalPrefix) << " = "; 1250 1251 // If this is a volatile load or store, print out the volatile marker. 1252 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1253 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) { 1254 Out << "volatile "; 1255 } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) { 1256 // If this is a call, check if it's a tail call. 1257 Out << "tail "; 1258 } 1259 1260 // Print out the opcode... 1261 Out << I.getOpcodeName(); 1262 1263 // Print out the compare instruction predicates 1264 if (const FCmpInst *FCI = dyn_cast<FCmpInst>(&I)) { 1265 Out << " " << getPredicateText(FCI->getPredicate()); 1266 } else if (const ICmpInst *ICI = dyn_cast<ICmpInst>(&I)) { 1267 Out << " " << getPredicateText(ICI->getPredicate()); 1268 } 1269 1270 // Print out the type of the operands... 1271 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1272 1273 // Special case conditional branches to swizzle the condition out to the front 1274 if (isa<BranchInst>(I) && I.getNumOperands() > 1) { 1275 writeOperand(I.getOperand(2), true); 1276 Out << ','; 1277 writeOperand(Operand, true); 1278 Out << ','; 1279 writeOperand(I.getOperand(1), true); 1280 1281 } else if (isa<SwitchInst>(I)) { 1282 // Special case switch statement to get formatting nice and correct... 1283 writeOperand(Operand , true); Out << ','; 1284 writeOperand(I.getOperand(1), true); Out << " ["; 1285 1286 for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { 1287 Out << "\n\t\t"; 1288 writeOperand(I.getOperand(op ), true); Out << ','; 1289 writeOperand(I.getOperand(op+1), true); 1290 } 1291 Out << "\n\t]"; 1292 } else if (isa<PHINode>(I)) { 1293 Out << ' '; 1294 printType(I.getType()); 1295 Out << ' '; 1296 1297 for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { 1298 if (op) Out << ", "; 1299 Out << '['; 1300 writeOperand(I.getOperand(op ), false); Out << ','; 1301 writeOperand(I.getOperand(op+1), false); Out << " ]"; 1302 } 1303 } else if (const GetResultInst *GRI = dyn_cast<GetResultInst>(&I)) { 1304 writeOperand(I.getOperand(0), true); 1305 Out << ", " << GRI->getIndex(); 1306 } else if (isa<ReturnInst>(I) && !Operand) { 1307 Out << " void"; 1308 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1309 // Print the calling convention being used. 1310 switch (CI->getCallingConv()) { 1311 case CallingConv::C: break; // default 1312 case CallingConv::Fast: Out << " fastcc"; break; 1313 case CallingConv::Cold: Out << " coldcc"; break; 1314 case CallingConv::X86_StdCall: Out << " x86_stdcallcc"; break; 1315 case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break; 1316 default: Out << " cc" << CI->getCallingConv(); break; 1317 } 1318 1319 const PointerType *PTy = cast<PointerType>(Operand->getType()); 1320 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1321 const Type *RetTy = FTy->getReturnType(); 1322 const PAListPtr &PAL = CI->getParamAttrs(); 1323 1324 // If possible, print out the short form of the call instruction. We can 1325 // only do this if the first argument is a pointer to a nonvararg function, 1326 // and if the return type is not a pointer to a function. 1327 // 1328 if (!FTy->isVarArg() && 1329 (!isa<PointerType>(RetTy) || 1330 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 1331 Out << ' '; printType(RetTy); 1332 writeOperand(Operand, false); 1333 } else { 1334 writeOperand(Operand, true); 1335 } 1336 Out << '('; 1337 for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { 1338 if (op > 1) 1339 Out << ','; 1340 writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op)); 1341 } 1342 Out << " )"; 1343 if (PAL.getParamAttrs(0) != ParamAttr::None) 1344 Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0)); 1345 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 1346 const PointerType *PTy = cast<PointerType>(Operand->getType()); 1347 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1348 const Type *RetTy = FTy->getReturnType(); 1349 const PAListPtr &PAL = II->getParamAttrs(); 1350 1351 // Print the calling convention being used. 1352 switch (II->getCallingConv()) { 1353 case CallingConv::C: break; // default 1354 case CallingConv::Fast: Out << " fastcc"; break; 1355 case CallingConv::Cold: Out << " coldcc"; break; 1356 case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; 1357 case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; 1358 default: Out << " cc" << II->getCallingConv(); break; 1359 } 1360 1361 // If possible, print out the short form of the invoke instruction. We can 1362 // only do this if the first argument is a pointer to a nonvararg function, 1363 // and if the return type is not a pointer to a function. 1364 // 1365 if (!FTy->isVarArg() && 1366 (!isa<PointerType>(RetTy) || 1367 !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { 1368 Out << ' '; printType(RetTy); 1369 writeOperand(Operand, false); 1370 } else { 1371 writeOperand(Operand, true); 1372 } 1373 1374 Out << '('; 1375 for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { 1376 if (op > 3) 1377 Out << ','; 1378 writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op-2)); 1379 } 1380 1381 Out << " )"; 1382 if (PAL.getParamAttrs(0) != ParamAttr::None) 1383 Out << " " << ParamAttr::getAsString(PAL.getParamAttrs(0)); 1384 Out << "\n\t\t\tto"; 1385 writeOperand(II->getNormalDest(), true); 1386 Out << " unwind"; 1387 writeOperand(II->getUnwindDest(), true); 1388 1389 } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { 1390 Out << ' '; 1391 printType(AI->getType()->getElementType()); 1392 if (AI->isArrayAllocation()) { 1393 Out << ','; 1394 writeOperand(AI->getArraySize(), true); 1395 } 1396 if (AI->getAlignment()) { 1397 Out << ", align " << AI->getAlignment(); 1398 } 1399 } else if (isa<CastInst>(I)) { 1400 if (Operand) writeOperand(Operand, true); // Work with broken code 1401 Out << " to "; 1402 printType(I.getType()); 1403 } else if (isa<VAArgInst>(I)) { 1404 if (Operand) writeOperand(Operand, true); // Work with broken code 1405 Out << ", "; 1406 printType(I.getType()); 1407 } else if (Operand) { // Print the normal way... 1408 1409 // PrintAllTypes - Instructions who have operands of all the same type 1410 // omit the type from all but the first operand. If the instruction has 1411 // different type operands (for example br), then they are all printed. 1412 bool PrintAllTypes = false; 1413 const Type *TheType = Operand->getType(); 1414 1415 // Select, Store and ShuffleVector always print all types. 1416 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I) 1417 || isa<ReturnInst>(I)) { 1418 PrintAllTypes = true; 1419 } else { 1420 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1421 Operand = I.getOperand(i); 1422 if (Operand->getType() != TheType) { 1423 PrintAllTypes = true; // We have differing types! Print them all! 1424 break; 1425 } 1426 } 1427 } 1428 1429 if (!PrintAllTypes) { 1430 Out << ' '; 1431 printType(TheType); 1432 } 1433 1434 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 1435 if (i) Out << ','; 1436 writeOperand(I.getOperand(i), PrintAllTypes); 1437 } 1438 } 1439 1440 // Print post operand alignment for load/store 1441 if (isa<LoadInst>(I) && cast<LoadInst>(I).getAlignment()) { 1442 Out << ", align " << cast<LoadInst>(I).getAlignment(); 1443 } else if (isa<StoreInst>(I) && cast<StoreInst>(I).getAlignment()) { 1444 Out << ", align " << cast<StoreInst>(I).getAlignment(); 1445 } 1446 1447 printInfoComment(I); 1448 Out << "\n"; 1449} 1450 1451 1452//===----------------------------------------------------------------------===// 1453// External Interface declarations 1454//===----------------------------------------------------------------------===// 1455 1456void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1457 SlotMachine SlotTable(this); 1458 AssemblyWriter W(o, SlotTable, this, AAW); 1459 W.write(this); 1460} 1461 1462void GlobalVariable::print(std::ostream &o) const { 1463 SlotMachine SlotTable(getParent()); 1464 AssemblyWriter W(o, SlotTable, getParent(), 0); 1465 W.write(this); 1466} 1467 1468void GlobalAlias::print(std::ostream &o) const { 1469 SlotMachine SlotTable(getParent()); 1470 AssemblyWriter W(o, SlotTable, getParent(), 0); 1471 W.write(this); 1472} 1473 1474void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1475 SlotMachine SlotTable(getParent()); 1476 AssemblyWriter W(o, SlotTable, getParent(), AAW); 1477 1478 W.write(this); 1479} 1480 1481void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1482 WriteAsOperand(o, this, true, 0); 1483} 1484 1485void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1486 SlotMachine SlotTable(getParent()); 1487 AssemblyWriter W(o, SlotTable, 1488 getParent() ? getParent()->getParent() : 0, AAW); 1489 W.write(this); 1490} 1491 1492void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { 1493 const Function *F = getParent() ? getParent()->getParent() : 0; 1494 SlotMachine SlotTable(F); 1495 AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW); 1496 1497 W.write(this); 1498} 1499 1500void Constant::print(std::ostream &o) const { 1501 if (this == 0) { o << "<null> constant value\n"; return; } 1502 1503 o << ' ' << getType()->getDescription() << ' '; 1504 1505 std::map<const Type *, std::string> TypeTable; 1506 WriteConstantInt(o, this, TypeTable, 0); 1507} 1508 1509void Type::print(std::ostream &o) const { 1510 if (this == 0) 1511 o << "<null Type>"; 1512 else 1513 o << getDescription(); 1514} 1515 1516void Argument::print(std::ostream &o) const { 1517 WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0); 1518} 1519 1520// Value::dump - allow easy printing of Values from the debugger. 1521// Located here because so much of the needed functionality is here. 1522void Value::dump() const { print(*cerr.stream()); cerr << '\n'; } 1523 1524// Type::dump - allow easy printing of Values from the debugger. 1525// Located here because so much of the needed functionality is here. 1526void Type::dump() const { print(*cerr.stream()); cerr << '\n'; } 1527 1528//===----------------------------------------------------------------------===// 1529// SlotMachine Implementation 1530//===----------------------------------------------------------------------===// 1531 1532#if 0 1533#define SC_DEBUG(X) cerr << X 1534#else 1535#define SC_DEBUG(X) 1536#endif 1537 1538// Module level constructor. Causes the contents of the Module (sans functions) 1539// to be added to the slot table. 1540SlotMachine::SlotMachine(const Module *M) 1541 : TheModule(M) ///< Saved for lazy initialization. 1542 , TheFunction(0) 1543 , FunctionProcessed(false) 1544 , mMap(), mNext(0), fMap(), fNext(0) 1545{ 1546} 1547 1548// Function level constructor. Causes the contents of the Module and the one 1549// function provided to be added to the slot table. 1550SlotMachine::SlotMachine(const Function *F) 1551 : TheModule(F ? F->getParent() : 0) ///< Saved for lazy initialization 1552 , TheFunction(F) ///< Saved for lazy initialization 1553 , FunctionProcessed(false) 1554 , mMap(), mNext(0), fMap(), fNext(0) 1555{ 1556} 1557 1558inline void SlotMachine::initialize() { 1559 if (TheModule) { 1560 processModule(); 1561 TheModule = 0; ///< Prevent re-processing next time we're called. 1562 } 1563 if (TheFunction && !FunctionProcessed) 1564 processFunction(); 1565} 1566 1567// Iterate through all the global variables, functions, and global 1568// variable initializers and create slots for them. 1569void SlotMachine::processModule() { 1570 SC_DEBUG("begin processModule!\n"); 1571 1572 // Add all of the unnamed global variables to the value table. 1573 for (Module::const_global_iterator I = TheModule->global_begin(), 1574 E = TheModule->global_end(); I != E; ++I) 1575 if (!I->hasName()) 1576 CreateModuleSlot(I); 1577 1578 // Add all the unnamed functions to the table. 1579 for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 1580 I != E; ++I) 1581 if (!I->hasName()) 1582 CreateModuleSlot(I); 1583 1584 SC_DEBUG("end processModule!\n"); 1585} 1586 1587 1588// Process the arguments, basic blocks, and instructions of a function. 1589void SlotMachine::processFunction() { 1590 SC_DEBUG("begin processFunction!\n"); 1591 fNext = 0; 1592 1593 // Add all the function arguments with no names. 1594 for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 1595 AE = TheFunction->arg_end(); AI != AE; ++AI) 1596 if (!AI->hasName()) 1597 CreateFunctionSlot(AI); 1598 1599 SC_DEBUG("Inserting Instructions:\n"); 1600 1601 // Add all of the basic blocks and instructions with no names. 1602 for (Function::const_iterator BB = TheFunction->begin(), 1603 E = TheFunction->end(); BB != E; ++BB) { 1604 if (!BB->hasName()) 1605 CreateFunctionSlot(BB); 1606 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) 1607 if (I->getType() != Type::VoidTy && !I->hasName()) 1608 CreateFunctionSlot(I); 1609 } 1610 1611 FunctionProcessed = true; 1612 1613 SC_DEBUG("end processFunction!\n"); 1614} 1615 1616/// Clean up after incorporating a function. This is the only way to get out of 1617/// the function incorporation state that affects get*Slot/Create*Slot. Function 1618/// incorporation state is indicated by TheFunction != 0. 1619void SlotMachine::purgeFunction() { 1620 SC_DEBUG("begin purgeFunction!\n"); 1621 fMap.clear(); // Simply discard the function level map 1622 TheFunction = 0; 1623 FunctionProcessed = false; 1624 SC_DEBUG("end purgeFunction!\n"); 1625} 1626 1627/// getGlobalSlot - Get the slot number of a global value. 1628int SlotMachine::getGlobalSlot(const GlobalValue *V) { 1629 // Check for uninitialized state and do lazy initialization. 1630 initialize(); 1631 1632 // Find the type plane in the module map 1633 ValueMap::const_iterator MI = mMap.find(V); 1634 if (MI == mMap.end()) return -1; 1635 1636 return MI->second; 1637} 1638 1639 1640/// getLocalSlot - Get the slot number for a value that is local to a function. 1641int SlotMachine::getLocalSlot(const Value *V) { 1642 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!"); 1643 1644 // Check for uninitialized state and do lazy initialization. 1645 initialize(); 1646 1647 ValueMap::const_iterator FI = fMap.find(V); 1648 if (FI == fMap.end()) return -1; 1649 1650 return FI->second; 1651} 1652 1653 1654/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 1655void SlotMachine::CreateModuleSlot(const GlobalValue *V) { 1656 assert(V && "Can't insert a null Value into SlotMachine!"); 1657 assert(V->getType() != Type::VoidTy && "Doesn't need a slot!"); 1658 assert(!V->hasName() && "Doesn't need a slot!"); 1659 1660 unsigned DestSlot = mNext++; 1661 mMap[V] = DestSlot; 1662 1663 SC_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << 1664 DestSlot << " ["); 1665 // G = Global, F = Function, A = Alias, o = other 1666 SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : 1667 (isa<Function> ? 'F' : 1668 (isa<GlobalAlias> ? 'A' : 'o'))) << "]\n"); 1669} 1670 1671 1672/// CreateSlot - Create a new slot for the specified value if it has no name. 1673void SlotMachine::CreateFunctionSlot(const Value *V) { 1674 const Type *VTy = V->getType(); 1675 assert(VTy != Type::VoidTy && !V->hasName() && "Doesn't need a slot!"); 1676 1677 unsigned DestSlot = fNext++; 1678 fMap[V] = DestSlot; 1679 1680 // G = Global, F = Function, o = other 1681 SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << 1682 DestSlot << " [o]\n"); 1683} 1684