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/ADT/DenseMap.h" 19 #include "llvm/ADT/STLExtras.h" 20 #include "llvm/ADT/SmallString.h" 21 #include "llvm/ADT/StringExtras.h" 22 #include "llvm/Assembly/AssemblyAnnotationWriter.h" 23 #include "llvm/Assembly/PrintModulePass.h" 24 #include "llvm/DebugInfo.h" 25 #include "llvm/IR/CallingConv.h" 26 #include "llvm/IR/Constants.h" 27 #include "llvm/IR/DerivedTypes.h" 28 #include "llvm/IR/InlineAsm.h" 29 #include "llvm/IR/IntrinsicInst.h" 30 #include "llvm/IR/LLVMContext.h" 31 #include "llvm/IR/Module.h" 32 #include "llvm/IR/Operator.h" 33 #include "llvm/IR/TypeFinder.h" 34 #include "llvm/IR/ValueSymbolTable.h" 35 #include "llvm/Support/CFG.h" 36 #include "llvm/Support/Debug.h" 37 #include "llvm/Support/Dwarf.h" 38 #include "llvm/Support/ErrorHandling.h" 39 #include "llvm/Support/FormattedStream.h" 40 #include "llvm/Support/MathExtras.h" 41 #include <algorithm> 42 #include <cctype> 43 using namespace llvm; 44 45 // Make virtual table appear in this compilation unit. 46 AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {} 47 48 //===----------------------------------------------------------------------===// 49 // Helper Functions 50 //===----------------------------------------------------------------------===// 51 52 static const Module *getModuleFromVal(const Value *V) { 53 if (const Argument *MA = dyn_cast<Argument>(V)) 54 return MA->getParent() ? MA->getParent()->getParent() : 0; 55 56 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 57 return BB->getParent() ? BB->getParent()->getParent() : 0; 58 59 if (const Instruction *I = dyn_cast<Instruction>(V)) { 60 const Function *M = I->getParent() ? I->getParent()->getParent() : 0; 61 return M ? M->getParent() : 0; 62 } 63 64 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 65 return GV->getParent(); 66 return 0; 67 } 68 69 static void PrintCallingConv(unsigned cc, raw_ostream &Out) { 70 switch (cc) { 71 default: Out << "cc" << cc; break; 72 case CallingConv::Fast: Out << "fastcc"; break; 73 case CallingConv::Cold: Out << "coldcc"; break; 74 case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break; 75 case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break; 76 case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break; 77 case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break; 78 case CallingConv::ARM_APCS: Out << "arm_apcscc"; break; 79 case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break; 80 case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break; 81 case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break; 82 case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break; 83 case CallingConv::PTX_Device: Out << "ptx_device"; break; 84 } 85 } 86 87 // PrintEscapedString - Print each character of the specified string, escaping 88 // it if it is not printable or if it is an escape char. 89 static void PrintEscapedString(StringRef Name, raw_ostream &Out) { 90 for (unsigned i = 0, e = Name.size(); i != e; ++i) { 91 unsigned char C = Name[i]; 92 if (isprint(C) && C != '\\' && C != '"') 93 Out << C; 94 else 95 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F); 96 } 97 } 98 99 enum PrefixType { 100 GlobalPrefix, 101 LabelPrefix, 102 LocalPrefix, 103 NoPrefix 104 }; 105 106 /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either 107 /// prefixed with % (if the string only contains simple characters) or is 108 /// surrounded with ""'s (if it has special chars in it). Print it out. 109 static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) { 110 assert(!Name.empty() && "Cannot get empty name!"); 111 switch (Prefix) { 112 case NoPrefix: break; 113 case GlobalPrefix: OS << '@'; break; 114 case LabelPrefix: break; 115 case LocalPrefix: OS << '%'; break; 116 } 117 118 // Scan the name to see if it needs quotes first. 119 bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0])); 120 if (!NeedsQuotes) { 121 for (unsigned i = 0, e = Name.size(); i != e; ++i) { 122 // By making this unsigned, the value passed in to isalnum will always be 123 // in the range 0-255. This is important when building with MSVC because 124 // its implementation will assert. This situation can arise when dealing 125 // with UTF-8 multibyte characters. 126 unsigned char C = Name[i]; 127 if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' && 128 C != '_') { 129 NeedsQuotes = true; 130 break; 131 } 132 } 133 } 134 135 // If we didn't need any quotes, just write out the name in one blast. 136 if (!NeedsQuotes) { 137 OS << Name; 138 return; 139 } 140 141 // Okay, we need quotes. Output the quotes and escape any scary characters as 142 // needed. 143 OS << '"'; 144 PrintEscapedString(Name, OS); 145 OS << '"'; 146 } 147 148 /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either 149 /// prefixed with % (if the string only contains simple characters) or is 150 /// surrounded with ""'s (if it has special chars in it). Print it out. 151 static void PrintLLVMName(raw_ostream &OS, const Value *V) { 152 PrintLLVMName(OS, V->getName(), 153 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix); 154 } 155 156 //===----------------------------------------------------------------------===// 157 // TypePrinting Class: Type printing machinery 158 //===----------------------------------------------------------------------===// 159 160 /// TypePrinting - Type printing machinery. 161 namespace { 162 class TypePrinting { 163 TypePrinting(const TypePrinting &) LLVM_DELETED_FUNCTION; 164 void operator=(const TypePrinting&) LLVM_DELETED_FUNCTION; 165 public: 166 167 /// NamedTypes - The named types that are used by the current module. 168 TypeFinder NamedTypes; 169 170 /// NumberedTypes - The numbered types, along with their value. 171 DenseMap<StructType*, unsigned> NumberedTypes; 172 173 174 TypePrinting() {} 175 ~TypePrinting() {} 176 177 void incorporateTypes(const Module &M); 178 179 void print(Type *Ty, raw_ostream &OS); 180 181 void printStructBody(StructType *Ty, raw_ostream &OS); 182 }; 183 } // end anonymous namespace. 184 185 186 void TypePrinting::incorporateTypes(const Module &M) { 187 NamedTypes.run(M, false); 188 189 // The list of struct types we got back includes all the struct types, split 190 // the unnamed ones out to a numbering and remove the anonymous structs. 191 unsigned NextNumber = 0; 192 193 std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E; 194 for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) { 195 StructType *STy = *I; 196 197 // Ignore anonymous types. 198 if (STy->isLiteral()) 199 continue; 200 201 if (STy->getName().empty()) 202 NumberedTypes[STy] = NextNumber++; 203 else 204 *NextToUse++ = STy; 205 } 206 207 NamedTypes.erase(NextToUse, NamedTypes.end()); 208 } 209 210 211 /// CalcTypeName - Write the specified type to the specified raw_ostream, making 212 /// use of type names or up references to shorten the type name where possible. 213 void TypePrinting::print(Type *Ty, raw_ostream &OS) { 214 switch (Ty->getTypeID()) { 215 case Type::VoidTyID: OS << "void"; break; 216 case Type::HalfTyID: OS << "half"; break; 217 case Type::FloatTyID: OS << "float"; break; 218 case Type::DoubleTyID: OS << "double"; break; 219 case Type::X86_FP80TyID: OS << "x86_fp80"; break; 220 case Type::FP128TyID: OS << "fp128"; break; 221 case Type::PPC_FP128TyID: OS << "ppc_fp128"; break; 222 case Type::LabelTyID: OS << "label"; break; 223 case Type::MetadataTyID: OS << "metadata"; break; 224 case Type::X86_MMXTyID: OS << "x86_mmx"; break; 225 case Type::IntegerTyID: 226 OS << 'i' << cast<IntegerType>(Ty)->getBitWidth(); 227 return; 228 229 case Type::FunctionTyID: { 230 FunctionType *FTy = cast<FunctionType>(Ty); 231 print(FTy->getReturnType(), OS); 232 OS << " ("; 233 for (FunctionType::param_iterator I = FTy->param_begin(), 234 E = FTy->param_end(); I != E; ++I) { 235 if (I != FTy->param_begin()) 236 OS << ", "; 237 print(*I, OS); 238 } 239 if (FTy->isVarArg()) { 240 if (FTy->getNumParams()) OS << ", "; 241 OS << "..."; 242 } 243 OS << ')'; 244 return; 245 } 246 case Type::StructTyID: { 247 StructType *STy = cast<StructType>(Ty); 248 249 if (STy->isLiteral()) 250 return printStructBody(STy, OS); 251 252 if (!STy->getName().empty()) 253 return PrintLLVMName(OS, STy->getName(), LocalPrefix); 254 255 DenseMap<StructType*, unsigned>::iterator I = NumberedTypes.find(STy); 256 if (I != NumberedTypes.end()) 257 OS << '%' << I->second; 258 else // Not enumerated, print the hex address. 259 OS << "%\"type " << STy << '\"'; 260 return; 261 } 262 case Type::PointerTyID: { 263 PointerType *PTy = cast<PointerType>(Ty); 264 print(PTy->getElementType(), OS); 265 if (unsigned AddressSpace = PTy->getAddressSpace()) 266 OS << " addrspace(" << AddressSpace << ')'; 267 OS << '*'; 268 return; 269 } 270 case Type::ArrayTyID: { 271 ArrayType *ATy = cast<ArrayType>(Ty); 272 OS << '[' << ATy->getNumElements() << " x "; 273 print(ATy->getElementType(), OS); 274 OS << ']'; 275 return; 276 } 277 case Type::VectorTyID: { 278 VectorType *PTy = cast<VectorType>(Ty); 279 OS << "<" << PTy->getNumElements() << " x "; 280 print(PTy->getElementType(), OS); 281 OS << '>'; 282 return; 283 } 284 default: 285 OS << "<unrecognized-type>"; 286 return; 287 } 288 } 289 290 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) { 291 if (STy->isOpaque()) { 292 OS << "opaque"; 293 return; 294 } 295 296 if (STy->isPacked()) 297 OS << '<'; 298 299 if (STy->getNumElements() == 0) { 300 OS << "{}"; 301 } else { 302 StructType::element_iterator I = STy->element_begin(); 303 OS << "{ "; 304 print(*I++, OS); 305 for (StructType::element_iterator E = STy->element_end(); I != E; ++I) { 306 OS << ", "; 307 print(*I, OS); 308 } 309 310 OS << " }"; 311 } 312 if (STy->isPacked()) 313 OS << '>'; 314 } 315 316 317 318 //===----------------------------------------------------------------------===// 319 // SlotTracker Class: Enumerate slot numbers for unnamed values 320 //===----------------------------------------------------------------------===// 321 322 namespace { 323 324 /// This class provides computation of slot numbers for LLVM Assembly writing. 325 /// 326 class SlotTracker { 327 public: 328 /// ValueMap - A mapping of Values to slot numbers. 329 typedef DenseMap<const Value*, unsigned> ValueMap; 330 331 private: 332 /// TheModule - The module for which we are holding slot numbers. 333 const Module* TheModule; 334 335 /// TheFunction - The function for which we are holding slot numbers. 336 const Function* TheFunction; 337 bool FunctionProcessed; 338 339 /// mMap - The slot map for the module level data. 340 ValueMap mMap; 341 unsigned mNext; 342 343 /// fMap - The slot map for the function level data. 344 ValueMap fMap; 345 unsigned fNext; 346 347 /// mdnMap - Map for MDNodes. 348 DenseMap<const MDNode*, unsigned> mdnMap; 349 unsigned mdnNext; 350 351 /// asMap - The slot map for attribute sets. 352 DenseMap<AttributeSet, unsigned> asMap; 353 unsigned asNext; 354 public: 355 /// Construct from a module 356 explicit SlotTracker(const Module *M); 357 /// Construct from a function, starting out in incorp state. 358 explicit SlotTracker(const Function *F); 359 360 /// Return the slot number of the specified value in it's type 361 /// plane. If something is not in the SlotTracker, return -1. 362 int getLocalSlot(const Value *V); 363 int getGlobalSlot(const GlobalValue *V); 364 int getMetadataSlot(const MDNode *N); 365 int getAttributeGroupSlot(AttributeSet AS); 366 367 /// If you'd like to deal with a function instead of just a module, use 368 /// this method to get its data into the SlotTracker. 369 void incorporateFunction(const Function *F) { 370 TheFunction = F; 371 FunctionProcessed = false; 372 } 373 374 /// After calling incorporateFunction, use this method to remove the 375 /// most recently incorporated function from the SlotTracker. This 376 /// will reset the state of the machine back to just the module contents. 377 void purgeFunction(); 378 379 /// MDNode map iterators. 380 typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator; 381 mdn_iterator mdn_begin() { return mdnMap.begin(); } 382 mdn_iterator mdn_end() { return mdnMap.end(); } 383 unsigned mdn_size() const { return mdnMap.size(); } 384 bool mdn_empty() const { return mdnMap.empty(); } 385 386 /// AttributeSet map iterators. 387 typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator; 388 as_iterator as_begin() { return asMap.begin(); } 389 as_iterator as_end() { return asMap.end(); } 390 unsigned as_size() const { return asMap.size(); } 391 bool as_empty() const { return asMap.empty(); } 392 393 /// This function does the actual initialization. 394 inline void initialize(); 395 396 // Implementation Details 397 private: 398 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 399 void CreateModuleSlot(const GlobalValue *V); 400 401 /// CreateMetadataSlot - Insert the specified MDNode* into the slot table. 402 void CreateMetadataSlot(const MDNode *N); 403 404 /// CreateFunctionSlot - Insert the specified Value* into the slot table. 405 void CreateFunctionSlot(const Value *V); 406 407 /// \brief Insert the specified AttributeSet into the slot table. 408 void CreateAttributeSetSlot(AttributeSet AS); 409 410 /// Add all of the module level global variables (and their initializers) 411 /// and function declarations, but not the contents of those functions. 412 void processModule(); 413 414 /// Add all of the functions arguments, basic blocks, and instructions. 415 void processFunction(); 416 417 SlotTracker(const SlotTracker &) LLVM_DELETED_FUNCTION; 418 void operator=(const SlotTracker &) LLVM_DELETED_FUNCTION; 419 }; 420 421 } // end anonymous namespace 422 423 424 static SlotTracker *createSlotTracker(const Value *V) { 425 if (const Argument *FA = dyn_cast<Argument>(V)) 426 return new SlotTracker(FA->getParent()); 427 428 if (const Instruction *I = dyn_cast<Instruction>(V)) 429 if (I->getParent()) 430 return new SlotTracker(I->getParent()->getParent()); 431 432 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) 433 return new SlotTracker(BB->getParent()); 434 435 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) 436 return new SlotTracker(GV->getParent()); 437 438 if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) 439 return new SlotTracker(GA->getParent()); 440 441 if (const Function *Func = dyn_cast<Function>(V)) 442 return new SlotTracker(Func); 443 444 if (const MDNode *MD = dyn_cast<MDNode>(V)) { 445 if (!MD->isFunctionLocal()) 446 return new SlotTracker(MD->getFunction()); 447 448 return new SlotTracker((Function *)0); 449 } 450 451 return 0; 452 } 453 454 #if 0 455 #define ST_DEBUG(X) dbgs() << X 456 #else 457 #define ST_DEBUG(X) 458 #endif 459 460 // Module level constructor. Causes the contents of the Module (sans functions) 461 // to be added to the slot table. 462 SlotTracker::SlotTracker(const Module *M) 463 : TheModule(M), TheFunction(0), FunctionProcessed(false), 464 mNext(0), fNext(0), mdnNext(0), asNext(0) { 465 } 466 467 // Function level constructor. Causes the contents of the Module and the one 468 // function provided to be added to the slot table. 469 SlotTracker::SlotTracker(const Function *F) 470 : TheModule(F ? F->getParent() : 0), TheFunction(F), FunctionProcessed(false), 471 mNext(0), fNext(0), mdnNext(0), asNext(0) { 472 } 473 474 inline void SlotTracker::initialize() { 475 if (TheModule) { 476 processModule(); 477 TheModule = 0; ///< Prevent re-processing next time we're called. 478 } 479 480 if (TheFunction && !FunctionProcessed) 481 processFunction(); 482 } 483 484 // Iterate through all the global variables, functions, and global 485 // variable initializers and create slots for them. 486 void SlotTracker::processModule() { 487 ST_DEBUG("begin processModule!\n"); 488 489 // Add all of the unnamed global variables to the value table. 490 for (Module::const_global_iterator I = TheModule->global_begin(), 491 E = TheModule->global_end(); I != E; ++I) { 492 if (!I->hasName()) 493 CreateModuleSlot(I); 494 } 495 496 // Add metadata used by named metadata. 497 for (Module::const_named_metadata_iterator 498 I = TheModule->named_metadata_begin(), 499 E = TheModule->named_metadata_end(); I != E; ++I) { 500 const NamedMDNode *NMD = I; 501 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) 502 CreateMetadataSlot(NMD->getOperand(i)); 503 } 504 505 for (Module::const_iterator I = TheModule->begin(), E = TheModule->end(); 506 I != E; ++I) { 507 if (!I->hasName()) 508 // Add all the unnamed functions to the table. 509 CreateModuleSlot(I); 510 511 // Add all the function attributes to the table. 512 // FIXME: Add attributes of other objects? 513 AttributeSet FnAttrs = I->getAttributes().getFnAttributes(); 514 if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex)) 515 CreateAttributeSetSlot(FnAttrs); 516 } 517 518 ST_DEBUG("end processModule!\n"); 519 } 520 521 // Process the arguments, basic blocks, and instructions of a function. 522 void SlotTracker::processFunction() { 523 ST_DEBUG("begin processFunction!\n"); 524 fNext = 0; 525 526 // Add all the function arguments with no names. 527 for(Function::const_arg_iterator AI = TheFunction->arg_begin(), 528 AE = TheFunction->arg_end(); AI != AE; ++AI) 529 if (!AI->hasName()) 530 CreateFunctionSlot(AI); 531 532 ST_DEBUG("Inserting Instructions:\n"); 533 534 SmallVector<std::pair<unsigned, MDNode*>, 4> MDForInst; 535 536 // Add all of the basic blocks and instructions with no names. 537 for (Function::const_iterator BB = TheFunction->begin(), 538 E = TheFunction->end(); BB != E; ++BB) { 539 if (!BB->hasName()) 540 CreateFunctionSlot(BB); 541 542 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; 543 ++I) { 544 if (!I->getType()->isVoidTy() && !I->hasName()) 545 CreateFunctionSlot(I); 546 547 // Intrinsics can directly use metadata. We allow direct calls to any 548 // llvm.foo function here, because the target may not be linked into the 549 // optimizer. 550 if (const CallInst *CI = dyn_cast<CallInst>(I)) { 551 if (Function *F = CI->getCalledFunction()) 552 if (F->getName().startswith("llvm.")) 553 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) 554 if (MDNode *N = dyn_cast_or_null<MDNode>(I->getOperand(i))) 555 CreateMetadataSlot(N); 556 557 // Add all the call attributes to the table. 558 AttributeSet Attrs = CI->getAttributes().getFnAttributes(); 559 if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) 560 CreateAttributeSetSlot(Attrs); 561 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) { 562 // Add all the call attributes to the table. 563 AttributeSet Attrs = II->getAttributes().getFnAttributes(); 564 if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) 565 CreateAttributeSetSlot(Attrs); 566 } 567 568 // Process metadata attached with this instruction. 569 I->getAllMetadata(MDForInst); 570 for (unsigned i = 0, e = MDForInst.size(); i != e; ++i) 571 CreateMetadataSlot(MDForInst[i].second); 572 MDForInst.clear(); 573 } 574 } 575 576 FunctionProcessed = true; 577 578 ST_DEBUG("end processFunction!\n"); 579 } 580 581 /// Clean up after incorporating a function. This is the only way to get out of 582 /// the function incorporation state that affects get*Slot/Create*Slot. Function 583 /// incorporation state is indicated by TheFunction != 0. 584 void SlotTracker::purgeFunction() { 585 ST_DEBUG("begin purgeFunction!\n"); 586 fMap.clear(); // Simply discard the function level map 587 TheFunction = 0; 588 FunctionProcessed = false; 589 ST_DEBUG("end purgeFunction!\n"); 590 } 591 592 /// getGlobalSlot - Get the slot number of a global value. 593 int SlotTracker::getGlobalSlot(const GlobalValue *V) { 594 // Check for uninitialized state and do lazy initialization. 595 initialize(); 596 597 // Find the value in the module map 598 ValueMap::iterator MI = mMap.find(V); 599 return MI == mMap.end() ? -1 : (int)MI->second; 600 } 601 602 /// getMetadataSlot - Get the slot number of a MDNode. 603 int SlotTracker::getMetadataSlot(const MDNode *N) { 604 // Check for uninitialized state and do lazy initialization. 605 initialize(); 606 607 // Find the MDNode in the module map 608 mdn_iterator MI = mdnMap.find(N); 609 return MI == mdnMap.end() ? -1 : (int)MI->second; 610 } 611 612 613 /// getLocalSlot - Get the slot number for a value that is local to a function. 614 int SlotTracker::getLocalSlot(const Value *V) { 615 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!"); 616 617 // Check for uninitialized state and do lazy initialization. 618 initialize(); 619 620 ValueMap::iterator FI = fMap.find(V); 621 return FI == fMap.end() ? -1 : (int)FI->second; 622 } 623 624 int SlotTracker::getAttributeGroupSlot(AttributeSet AS) { 625 // Check for uninitialized state and do lazy initialization. 626 initialize(); 627 628 // Find the AttributeSet in the module map. 629 as_iterator AI = asMap.find(AS); 630 return AI == asMap.end() ? -1 : (int)AI->second; 631 } 632 633 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table. 634 void SlotTracker::CreateModuleSlot(const GlobalValue *V) { 635 assert(V && "Can't insert a null Value into SlotTracker!"); 636 assert(!V->getType()->isVoidTy() && "Doesn't need a slot!"); 637 assert(!V->hasName() && "Doesn't need a slot!"); 638 639 unsigned DestSlot = mNext++; 640 mMap[V] = DestSlot; 641 642 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << 643 DestSlot << " ["); 644 // G = Global, F = Function, A = Alias, o = other 645 ST_DEBUG((isa<GlobalVariable>(V) ? 'G' : 646 (isa<Function>(V) ? 'F' : 647 (isa<GlobalAlias>(V) ? 'A' : 'o'))) << "]\n"); 648 } 649 650 /// CreateSlot - Create a new slot for the specified value if it has no name. 651 void SlotTracker::CreateFunctionSlot(const Value *V) { 652 assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!"); 653 654 unsigned DestSlot = fNext++; 655 fMap[V] = DestSlot; 656 657 // G = Global, F = Function, o = other 658 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" << 659 DestSlot << " [o]\n"); 660 } 661 662 /// CreateModuleSlot - Insert the specified MDNode* into the slot table. 663 void SlotTracker::CreateMetadataSlot(const MDNode *N) { 664 assert(N && "Can't insert a null Value into SlotTracker!"); 665 666 // Don't insert if N is a function-local metadata, these are always printed 667 // inline. 668 if (!N->isFunctionLocal()) { 669 mdn_iterator I = mdnMap.find(N); 670 if (I != mdnMap.end()) 671 return; 672 673 unsigned DestSlot = mdnNext++; 674 mdnMap[N] = DestSlot; 675 } 676 677 // Recursively add any MDNodes referenced by operands. 678 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 679 if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i))) 680 CreateMetadataSlot(Op); 681 } 682 683 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) { 684 assert(AS.hasAttributes(AttributeSet::FunctionIndex) && 685 "Doesn't need a slot!"); 686 687 as_iterator I = asMap.find(AS); 688 if (I != asMap.end()) 689 return; 690 691 unsigned DestSlot = asNext++; 692 asMap[AS] = DestSlot; 693 } 694 695 //===----------------------------------------------------------------------===// 696 // AsmWriter Implementation 697 //===----------------------------------------------------------------------===// 698 699 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, 700 TypePrinting *TypePrinter, 701 SlotTracker *Machine, 702 const Module *Context); 703 704 705 706 static const char *getPredicateText(unsigned predicate) { 707 const char * pred = "unknown"; 708 switch (predicate) { 709 case FCmpInst::FCMP_FALSE: pred = "false"; break; 710 case FCmpInst::FCMP_OEQ: pred = "oeq"; break; 711 case FCmpInst::FCMP_OGT: pred = "ogt"; break; 712 case FCmpInst::FCMP_OGE: pred = "oge"; break; 713 case FCmpInst::FCMP_OLT: pred = "olt"; break; 714 case FCmpInst::FCMP_OLE: pred = "ole"; break; 715 case FCmpInst::FCMP_ONE: pred = "one"; break; 716 case FCmpInst::FCMP_ORD: pred = "ord"; break; 717 case FCmpInst::FCMP_UNO: pred = "uno"; break; 718 case FCmpInst::FCMP_UEQ: pred = "ueq"; break; 719 case FCmpInst::FCMP_UGT: pred = "ugt"; break; 720 case FCmpInst::FCMP_UGE: pred = "uge"; break; 721 case FCmpInst::FCMP_ULT: pred = "ult"; break; 722 case FCmpInst::FCMP_ULE: pred = "ule"; break; 723 case FCmpInst::FCMP_UNE: pred = "une"; break; 724 case FCmpInst::FCMP_TRUE: pred = "true"; break; 725 case ICmpInst::ICMP_EQ: pred = "eq"; break; 726 case ICmpInst::ICMP_NE: pred = "ne"; break; 727 case ICmpInst::ICMP_SGT: pred = "sgt"; break; 728 case ICmpInst::ICMP_SGE: pred = "sge"; break; 729 case ICmpInst::ICMP_SLT: pred = "slt"; break; 730 case ICmpInst::ICMP_SLE: pred = "sle"; break; 731 case ICmpInst::ICMP_UGT: pred = "ugt"; break; 732 case ICmpInst::ICMP_UGE: pred = "uge"; break; 733 case ICmpInst::ICMP_ULT: pred = "ult"; break; 734 case ICmpInst::ICMP_ULE: pred = "ule"; break; 735 } 736 return pred; 737 } 738 739 static void writeAtomicRMWOperation(raw_ostream &Out, 740 AtomicRMWInst::BinOp Op) { 741 switch (Op) { 742 default: Out << " <unknown operation " << Op << ">"; break; 743 case AtomicRMWInst::Xchg: Out << " xchg"; break; 744 case AtomicRMWInst::Add: Out << " add"; break; 745 case AtomicRMWInst::Sub: Out << " sub"; break; 746 case AtomicRMWInst::And: Out << " and"; break; 747 case AtomicRMWInst::Nand: Out << " nand"; break; 748 case AtomicRMWInst::Or: Out << " or"; break; 749 case AtomicRMWInst::Xor: Out << " xor"; break; 750 case AtomicRMWInst::Max: Out << " max"; break; 751 case AtomicRMWInst::Min: Out << " min"; break; 752 case AtomicRMWInst::UMax: Out << " umax"; break; 753 case AtomicRMWInst::UMin: Out << " umin"; break; 754 } 755 } 756 757 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) { 758 if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) { 759 // Unsafe algebra implies all the others, no need to write them all out 760 if (FPO->hasUnsafeAlgebra()) 761 Out << " fast"; 762 else { 763 if (FPO->hasNoNaNs()) 764 Out << " nnan"; 765 if (FPO->hasNoInfs()) 766 Out << " ninf"; 767 if (FPO->hasNoSignedZeros()) 768 Out << " nsz"; 769 if (FPO->hasAllowReciprocal()) 770 Out << " arcp"; 771 } 772 } 773 774 if (const OverflowingBinaryOperator *OBO = 775 dyn_cast<OverflowingBinaryOperator>(U)) { 776 if (OBO->hasNoUnsignedWrap()) 777 Out << " nuw"; 778 if (OBO->hasNoSignedWrap()) 779 Out << " nsw"; 780 } else if (const PossiblyExactOperator *Div = 781 dyn_cast<PossiblyExactOperator>(U)) { 782 if (Div->isExact()) 783 Out << " exact"; 784 } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) { 785 if (GEP->isInBounds()) 786 Out << " inbounds"; 787 } 788 } 789 790 static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, 791 TypePrinting &TypePrinter, 792 SlotTracker *Machine, 793 const Module *Context) { 794 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 795 if (CI->getType()->isIntegerTy(1)) { 796 Out << (CI->getZExtValue() ? "true" : "false"); 797 return; 798 } 799 Out << CI->getValue(); 800 return; 801 } 802 803 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 804 if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle || 805 &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble) { 806 // We would like to output the FP constant value in exponential notation, 807 // but we cannot do this if doing so will lose precision. Check here to 808 // make sure that we only output it in exponential format if we can parse 809 // the value back and get the same value. 810 // 811 bool ignored; 812 bool isHalf = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEhalf; 813 bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble; 814 bool isInf = CFP->getValueAPF().isInfinity(); 815 bool isNaN = CFP->getValueAPF().isNaN(); 816 if (!isHalf && !isInf && !isNaN) { 817 double Val = isDouble ? CFP->getValueAPF().convertToDouble() : 818 CFP->getValueAPF().convertToFloat(); 819 SmallString<128> StrVal; 820 raw_svector_ostream(StrVal) << Val; 821 822 // Check to make sure that the stringized number is not some string like 823 // "Inf" or NaN, that atof will accept, but the lexer will not. Check 824 // that the string matches the "[-+]?[0-9]" regex. 825 // 826 if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 827 ((StrVal[0] == '-' || StrVal[0] == '+') && 828 (StrVal[1] >= '0' && StrVal[1] <= '9'))) { 829 // Reparse stringized version! 830 if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) { 831 Out << StrVal.str(); 832 return; 833 } 834 } 835 } 836 // Otherwise we could not reparse it to exactly the same value, so we must 837 // output the string in hexadecimal format! Note that loading and storing 838 // floating point types changes the bits of NaNs on some hosts, notably 839 // x86, so we must not use these types. 840 assert(sizeof(double) == sizeof(uint64_t) && 841 "assuming that double is 64 bits!"); 842 char Buffer[40]; 843 APFloat apf = CFP->getValueAPF(); 844 // Halves and floats are represented in ASCII IR as double, convert. 845 if (!isDouble) 846 apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 847 &ignored); 848 Out << "0x" << 849 utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()), 850 Buffer+40); 851 return; 852 } 853 854 // Either half, or some form of long double. 855 // These appear as a magic letter identifying the type, then a 856 // fixed number of hex digits. 857 Out << "0x"; 858 // Bit position, in the current word, of the next nibble to print. 859 int shiftcount; 860 861 if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) { 862 Out << 'K'; 863 // api needed to prevent premature destruction 864 APInt api = CFP->getValueAPF().bitcastToAPInt(); 865 const uint64_t* p = api.getRawData(); 866 uint64_t word = p[1]; 867 shiftcount = 12; 868 int width = api.getBitWidth(); 869 for (int j=0; j<width; j+=4, shiftcount-=4) { 870 unsigned int nibble = (word>>shiftcount) & 15; 871 if (nibble < 10) 872 Out << (unsigned char)(nibble + '0'); 873 else 874 Out << (unsigned char)(nibble - 10 + 'A'); 875 if (shiftcount == 0 && j+4 < width) { 876 word = *p; 877 shiftcount = 64; 878 if (width-j-4 < 64) 879 shiftcount = width-j-4; 880 } 881 } 882 return; 883 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) { 884 shiftcount = 60; 885 Out << 'L'; 886 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) { 887 shiftcount = 60; 888 Out << 'M'; 889 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEhalf) { 890 shiftcount = 12; 891 Out << 'H'; 892 } else 893 llvm_unreachable("Unsupported floating point type"); 894 // api needed to prevent premature destruction 895 APInt api = CFP->getValueAPF().bitcastToAPInt(); 896 const uint64_t* p = api.getRawData(); 897 uint64_t word = *p; 898 int width = api.getBitWidth(); 899 for (int j=0; j<width; j+=4, shiftcount-=4) { 900 unsigned int nibble = (word>>shiftcount) & 15; 901 if (nibble < 10) 902 Out << (unsigned char)(nibble + '0'); 903 else 904 Out << (unsigned char)(nibble - 10 + 'A'); 905 if (shiftcount == 0 && j+4 < width) { 906 word = *(++p); 907 shiftcount = 64; 908 if (width-j-4 < 64) 909 shiftcount = width-j-4; 910 } 911 } 912 return; 913 } 914 915 if (isa<ConstantAggregateZero>(CV)) { 916 Out << "zeroinitializer"; 917 return; 918 } 919 920 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) { 921 Out << "blockaddress("; 922 WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine, 923 Context); 924 Out << ", "; 925 WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine, 926 Context); 927 Out << ")"; 928 return; 929 } 930 931 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 932 Type *ETy = CA->getType()->getElementType(); 933 Out << '['; 934 TypePrinter.print(ETy, Out); 935 Out << ' '; 936 WriteAsOperandInternal(Out, CA->getOperand(0), 937 &TypePrinter, Machine, 938 Context); 939 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 940 Out << ", "; 941 TypePrinter.print(ETy, Out); 942 Out << ' '; 943 WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine, 944 Context); 945 } 946 Out << ']'; 947 return; 948 } 949 950 if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) { 951 // As a special case, print the array as a string if it is an array of 952 // i8 with ConstantInt values. 953 if (CA->isString()) { 954 Out << "c\""; 955 PrintEscapedString(CA->getAsString(), Out); 956 Out << '"'; 957 return; 958 } 959 960 Type *ETy = CA->getType()->getElementType(); 961 Out << '['; 962 TypePrinter.print(ETy, Out); 963 Out << ' '; 964 WriteAsOperandInternal(Out, CA->getElementAsConstant(0), 965 &TypePrinter, Machine, 966 Context); 967 for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) { 968 Out << ", "; 969 TypePrinter.print(ETy, Out); 970 Out << ' '; 971 WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter, 972 Machine, Context); 973 } 974 Out << ']'; 975 return; 976 } 977 978 979 if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 980 if (CS->getType()->isPacked()) 981 Out << '<'; 982 Out << '{'; 983 unsigned N = CS->getNumOperands(); 984 if (N) { 985 Out << ' '; 986 TypePrinter.print(CS->getOperand(0)->getType(), Out); 987 Out << ' '; 988 989 WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine, 990 Context); 991 992 for (unsigned i = 1; i < N; i++) { 993 Out << ", "; 994 TypePrinter.print(CS->getOperand(i)->getType(), Out); 995 Out << ' '; 996 997 WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine, 998 Context); 999 } 1000 Out << ' '; 1001 } 1002 1003 Out << '}'; 1004 if (CS->getType()->isPacked()) 1005 Out << '>'; 1006 return; 1007 } 1008 1009 if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) { 1010 Type *ETy = CV->getType()->getVectorElementType(); 1011 Out << '<'; 1012 TypePrinter.print(ETy, Out); 1013 Out << ' '; 1014 WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter, 1015 Machine, Context); 1016 for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){ 1017 Out << ", "; 1018 TypePrinter.print(ETy, Out); 1019 Out << ' '; 1020 WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter, 1021 Machine, Context); 1022 } 1023 Out << '>'; 1024 return; 1025 } 1026 1027 if (isa<ConstantPointerNull>(CV)) { 1028 Out << "null"; 1029 return; 1030 } 1031 1032 if (isa<UndefValue>(CV)) { 1033 Out << "undef"; 1034 return; 1035 } 1036 1037 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 1038 Out << CE->getOpcodeName(); 1039 WriteOptimizationInfo(Out, CE); 1040 if (CE->isCompare()) 1041 Out << ' ' << getPredicateText(CE->getPredicate()); 1042 Out << " ("; 1043 1044 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 1045 TypePrinter.print((*OI)->getType(), Out); 1046 Out << ' '; 1047 WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context); 1048 if (OI+1 != CE->op_end()) 1049 Out << ", "; 1050 } 1051 1052 if (CE->hasIndices()) { 1053 ArrayRef<unsigned> Indices = CE->getIndices(); 1054 for (unsigned i = 0, e = Indices.size(); i != e; ++i) 1055 Out << ", " << Indices[i]; 1056 } 1057 1058 if (CE->isCast()) { 1059 Out << " to "; 1060 TypePrinter.print(CE->getType(), Out); 1061 } 1062 1063 Out << ')'; 1064 return; 1065 } 1066 1067 Out << "<placeholder or erroneous Constant>"; 1068 } 1069 1070 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, 1071 TypePrinting *TypePrinter, 1072 SlotTracker *Machine, 1073 const Module *Context) { 1074 Out << "!{"; 1075 for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) { 1076 const Value *V = Node->getOperand(mi); 1077 if (V == 0) 1078 Out << "null"; 1079 else { 1080 TypePrinter->print(V->getType(), Out); 1081 Out << ' '; 1082 WriteAsOperandInternal(Out, Node->getOperand(mi), 1083 TypePrinter, Machine, Context); 1084 } 1085 if (mi + 1 != me) 1086 Out << ", "; 1087 } 1088 1089 Out << "}"; 1090 } 1091 1092 1093 /// WriteAsOperand - Write the name of the specified value out to the specified 1094 /// ostream. This can be useful when you just want to print int %reg126, not 1095 /// the whole instruction that generated it. 1096 /// 1097 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, 1098 TypePrinting *TypePrinter, 1099 SlotTracker *Machine, 1100 const Module *Context) { 1101 if (V->hasName()) { 1102 PrintLLVMName(Out, V); 1103 return; 1104 } 1105 1106 const Constant *CV = dyn_cast<Constant>(V); 1107 if (CV && !isa<GlobalValue>(CV)) { 1108 assert(TypePrinter && "Constants require TypePrinting!"); 1109 WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context); 1110 return; 1111 } 1112 1113 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 1114 Out << "asm "; 1115 if (IA->hasSideEffects()) 1116 Out << "sideeffect "; 1117 if (IA->isAlignStack()) 1118 Out << "alignstack "; 1119 // We don't emit the AD_ATT dialect as it's the assumed default. 1120 if (IA->getDialect() == InlineAsm::AD_Intel) 1121 Out << "inteldialect "; 1122 Out << '"'; 1123 PrintEscapedString(IA->getAsmString(), Out); 1124 Out << "\", \""; 1125 PrintEscapedString(IA->getConstraintString(), Out); 1126 Out << '"'; 1127 return; 1128 } 1129 1130 if (const MDNode *N = dyn_cast<MDNode>(V)) { 1131 if (N->isFunctionLocal()) { 1132 // Print metadata inline, not via slot reference number. 1133 WriteMDNodeBodyInternal(Out, N, TypePrinter, Machine, Context); 1134 return; 1135 } 1136 1137 if (!Machine) { 1138 if (N->isFunctionLocal()) 1139 Machine = new SlotTracker(N->getFunction()); 1140 else 1141 Machine = new SlotTracker(Context); 1142 } 1143 int Slot = Machine->getMetadataSlot(N); 1144 if (Slot == -1) 1145 Out << "<badref>"; 1146 else 1147 Out << '!' << Slot; 1148 return; 1149 } 1150 1151 if (const MDString *MDS = dyn_cast<MDString>(V)) { 1152 Out << "!\""; 1153 PrintEscapedString(MDS->getString(), Out); 1154 Out << '"'; 1155 return; 1156 } 1157 1158 if (V->getValueID() == Value::PseudoSourceValueVal || 1159 V->getValueID() == Value::FixedStackPseudoSourceValueVal) { 1160 V->print(Out); 1161 return; 1162 } 1163 1164 char Prefix = '%'; 1165 int Slot; 1166 // If we have a SlotTracker, use it. 1167 if (Machine) { 1168 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1169 Slot = Machine->getGlobalSlot(GV); 1170 Prefix = '@'; 1171 } else { 1172 Slot = Machine->getLocalSlot(V); 1173 1174 // If the local value didn't succeed, then we may be referring to a value 1175 // from a different function. Translate it, as this can happen when using 1176 // address of blocks. 1177 if (Slot == -1) 1178 if ((Machine = createSlotTracker(V))) { 1179 Slot = Machine->getLocalSlot(V); 1180 delete Machine; 1181 } 1182 } 1183 } else if ((Machine = createSlotTracker(V))) { 1184 // Otherwise, create one to get the # and then destroy it. 1185 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1186 Slot = Machine->getGlobalSlot(GV); 1187 Prefix = '@'; 1188 } else { 1189 Slot = Machine->getLocalSlot(V); 1190 } 1191 delete Machine; 1192 Machine = 0; 1193 } else { 1194 Slot = -1; 1195 } 1196 1197 if (Slot != -1) 1198 Out << Prefix << Slot; 1199 else 1200 Out << "<badref>"; 1201 } 1202 1203 void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, 1204 bool PrintType, const Module *Context) { 1205 1206 // Fast path: Don't construct and populate a TypePrinting object if we 1207 // won't be needing any types printed. 1208 if (!PrintType && 1209 ((!isa<Constant>(V) && !isa<MDNode>(V)) || 1210 V->hasName() || isa<GlobalValue>(V))) { 1211 WriteAsOperandInternal(Out, V, 0, 0, Context); 1212 return; 1213 } 1214 1215 if (Context == 0) Context = getModuleFromVal(V); 1216 1217 TypePrinting TypePrinter; 1218 if (Context) 1219 TypePrinter.incorporateTypes(*Context); 1220 if (PrintType) { 1221 TypePrinter.print(V->getType(), Out); 1222 Out << ' '; 1223 } 1224 1225 WriteAsOperandInternal(Out, V, &TypePrinter, 0, Context); 1226 } 1227 1228 namespace { 1229 1230 class AssemblyWriter { 1231 formatted_raw_ostream &Out; 1232 SlotTracker &Machine; 1233 const Module *TheModule; 1234 TypePrinting TypePrinter; 1235 AssemblyAnnotationWriter *AnnotationWriter; 1236 1237 public: 1238 inline AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, 1239 const Module *M, 1240 AssemblyAnnotationWriter *AAW) 1241 : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 1242 if (M) 1243 TypePrinter.incorporateTypes(*M); 1244 } 1245 1246 void printMDNodeBody(const MDNode *MD); 1247 void printNamedMDNode(const NamedMDNode *NMD); 1248 1249 void printModule(const Module *M); 1250 1251 void writeOperand(const Value *Op, bool PrintType); 1252 void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx); 1253 void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope); 1254 1255 void writeAllMDNodes(); 1256 void writeAllAttributeGroups(); 1257 1258 void printTypeIdentities(); 1259 void printGlobal(const GlobalVariable *GV); 1260 void printAlias(const GlobalAlias *GV); 1261 void printFunction(const Function *F); 1262 void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx); 1263 void printBasicBlock(const BasicBlock *BB); 1264 void printInstruction(const Instruction &I); 1265 1266 private: 1267 // printInfoComment - Print a little comment after the instruction indicating 1268 // which slot it occupies. 1269 void printInfoComment(const Value &V); 1270 }; 1271 } // end of anonymous namespace 1272 1273 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 1274 if (Operand == 0) { 1275 Out << "<null operand!>"; 1276 return; 1277 } 1278 if (PrintType) { 1279 TypePrinter.print(Operand->getType(), Out); 1280 Out << ' '; 1281 } 1282 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); 1283 } 1284 1285 void AssemblyWriter::writeAtomic(AtomicOrdering Ordering, 1286 SynchronizationScope SynchScope) { 1287 if (Ordering == NotAtomic) 1288 return; 1289 1290 switch (SynchScope) { 1291 case SingleThread: Out << " singlethread"; break; 1292 case CrossThread: break; 1293 } 1294 1295 switch (Ordering) { 1296 default: Out << " <bad ordering " << int(Ordering) << ">"; break; 1297 case Unordered: Out << " unordered"; break; 1298 case Monotonic: Out << " monotonic"; break; 1299 case Acquire: Out << " acquire"; break; 1300 case Release: Out << " release"; break; 1301 case AcquireRelease: Out << " acq_rel"; break; 1302 case SequentiallyConsistent: Out << " seq_cst"; break; 1303 } 1304 } 1305 1306 void AssemblyWriter::writeParamOperand(const Value *Operand, 1307 AttributeSet Attrs, unsigned Idx) { 1308 if (Operand == 0) { 1309 Out << "<null operand!>"; 1310 return; 1311 } 1312 1313 // Print the type 1314 TypePrinter.print(Operand->getType(), Out); 1315 // Print parameter attributes list 1316 if (Attrs.hasAttributes(Idx)) 1317 Out << ' ' << Attrs.getAsString(Idx); 1318 Out << ' '; 1319 // Print the operand 1320 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); 1321 } 1322 1323 void AssemblyWriter::printModule(const Module *M) { 1324 Machine.initialize(); 1325 1326 if (!M->getModuleIdentifier().empty() && 1327 // Don't print the ID if it will start a new line (which would 1328 // require a comment char before it). 1329 M->getModuleIdentifier().find('\n') == std::string::npos) 1330 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 1331 1332 if (!M->getDataLayout().empty()) 1333 Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 1334 if (!M->getTargetTriple().empty()) 1335 Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 1336 1337 if (!M->getModuleInlineAsm().empty()) { 1338 // Split the string into lines, to make it easier to read the .ll file. 1339 std::string Asm = M->getModuleInlineAsm(); 1340 size_t CurPos = 0; 1341 size_t NewLine = Asm.find_first_of('\n', CurPos); 1342 Out << '\n'; 1343 while (NewLine != std::string::npos) { 1344 // We found a newline, print the portion of the asm string from the 1345 // last newline up to this newline. 1346 Out << "module asm \""; 1347 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 1348 Out); 1349 Out << "\"\n"; 1350 CurPos = NewLine+1; 1351 NewLine = Asm.find_first_of('\n', CurPos); 1352 } 1353 std::string rest(Asm.begin()+CurPos, Asm.end()); 1354 if (!rest.empty()) { 1355 Out << "module asm \""; 1356 PrintEscapedString(rest, Out); 1357 Out << "\"\n"; 1358 } 1359 } 1360 1361 printTypeIdentities(); 1362 1363 // Output all globals. 1364 if (!M->global_empty()) Out << '\n'; 1365 for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 1366 I != E; ++I) { 1367 printGlobal(I); Out << '\n'; 1368 } 1369 1370 // Output all aliases. 1371 if (!M->alias_empty()) Out << "\n"; 1372 for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 1373 I != E; ++I) 1374 printAlias(I); 1375 1376 // Output all of the functions. 1377 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 1378 printFunction(I); 1379 1380 // Output all attribute groups. 1381 if (!Machine.as_empty()) { 1382 Out << '\n'; 1383 writeAllAttributeGroups(); 1384 } 1385 1386 // Output named metadata. 1387 if (!M->named_metadata_empty()) Out << '\n'; 1388 1389 for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), 1390 E = M->named_metadata_end(); I != E; ++I) 1391 printNamedMDNode(I); 1392 1393 // Output metadata. 1394 if (!Machine.mdn_empty()) { 1395 Out << '\n'; 1396 writeAllMDNodes(); 1397 } 1398 } 1399 1400 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) { 1401 Out << '!'; 1402 StringRef Name = NMD->getName(); 1403 if (Name.empty()) { 1404 Out << "<empty name> "; 1405 } else { 1406 if (isalpha(static_cast<unsigned char>(Name[0])) || 1407 Name[0] == '-' || Name[0] == '$' || 1408 Name[0] == '.' || Name[0] == '_') 1409 Out << Name[0]; 1410 else 1411 Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F); 1412 for (unsigned i = 1, e = Name.size(); i != e; ++i) { 1413 unsigned char C = Name[i]; 1414 if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' || 1415 C == '.' || C == '_') 1416 Out << C; 1417 else 1418 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F); 1419 } 1420 } 1421 Out << " = !{"; 1422 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1423 if (i) Out << ", "; 1424 int Slot = Machine.getMetadataSlot(NMD->getOperand(i)); 1425 if (Slot == -1) 1426 Out << "<badref>"; 1427 else 1428 Out << '!' << Slot; 1429 } 1430 Out << "}\n"; 1431 } 1432 1433 1434 static void PrintLinkage(GlobalValue::LinkageTypes LT, 1435 formatted_raw_ostream &Out) { 1436 switch (LT) { 1437 case GlobalValue::ExternalLinkage: break; 1438 case GlobalValue::PrivateLinkage: Out << "private "; break; 1439 case GlobalValue::LinkerPrivateLinkage: Out << "linker_private "; break; 1440 case GlobalValue::LinkerPrivateWeakLinkage: 1441 Out << "linker_private_weak "; 1442 break; 1443 case GlobalValue::InternalLinkage: Out << "internal "; break; 1444 case GlobalValue::LinkOnceAnyLinkage: Out << "linkonce "; break; 1445 case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break; 1446 case GlobalValue::LinkOnceODRAutoHideLinkage: 1447 Out << "linkonce_odr_auto_hide "; 1448 break; 1449 case GlobalValue::WeakAnyLinkage: Out << "weak "; break; 1450 case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break; 1451 case GlobalValue::CommonLinkage: Out << "common "; break; 1452 case GlobalValue::AppendingLinkage: Out << "appending "; break; 1453 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 1454 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 1455 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 1456 case GlobalValue::AvailableExternallyLinkage: 1457 Out << "available_externally "; 1458 break; 1459 } 1460 } 1461 1462 1463 static void PrintVisibility(GlobalValue::VisibilityTypes Vis, 1464 formatted_raw_ostream &Out) { 1465 switch (Vis) { 1466 case GlobalValue::DefaultVisibility: break; 1467 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 1468 case GlobalValue::ProtectedVisibility: Out << "protected "; break; 1469 } 1470 } 1471 1472 static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, 1473 formatted_raw_ostream &Out) { 1474 switch (TLM) { 1475 case GlobalVariable::NotThreadLocal: 1476 break; 1477 case GlobalVariable::GeneralDynamicTLSModel: 1478 Out << "thread_local "; 1479 break; 1480 case GlobalVariable::LocalDynamicTLSModel: 1481 Out << "thread_local(localdynamic) "; 1482 break; 1483 case GlobalVariable::InitialExecTLSModel: 1484 Out << "thread_local(initialexec) "; 1485 break; 1486 case GlobalVariable::LocalExecTLSModel: 1487 Out << "thread_local(localexec) "; 1488 break; 1489 } 1490 } 1491 1492 void AssemblyWriter::printGlobal(const GlobalVariable *GV) { 1493 if (GV->isMaterializable()) 1494 Out << "; Materializable\n"; 1495 1496 WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent()); 1497 Out << " = "; 1498 1499 if (!GV->hasInitializer() && GV->hasExternalLinkage()) 1500 Out << "external "; 1501 1502 PrintLinkage(GV->getLinkage(), Out); 1503 PrintVisibility(GV->getVisibility(), Out); 1504 PrintThreadLocalModel(GV->getThreadLocalMode(), Out); 1505 1506 if (unsigned AddressSpace = GV->getType()->getAddressSpace()) 1507 Out << "addrspace(" << AddressSpace << ") "; 1508 if (GV->hasUnnamedAddr()) Out << "unnamed_addr "; 1509 if (GV->isExternallyInitialized()) Out << "externally_initialized "; 1510 Out << (GV->isConstant() ? "constant " : "global "); 1511 TypePrinter.print(GV->getType()->getElementType(), Out); 1512 1513 if (GV->hasInitializer()) { 1514 Out << ' '; 1515 writeOperand(GV->getInitializer(), false); 1516 } 1517 1518 if (GV->hasSection()) { 1519 Out << ", section \""; 1520 PrintEscapedString(GV->getSection(), Out); 1521 Out << '"'; 1522 } 1523 if (GV->getAlignment()) 1524 Out << ", align " << GV->getAlignment(); 1525 1526 printInfoComment(*GV); 1527 } 1528 1529 void AssemblyWriter::printAlias(const GlobalAlias *GA) { 1530 if (GA->isMaterializable()) 1531 Out << "; Materializable\n"; 1532 1533 // Don't crash when dumping partially built GA 1534 if (!GA->hasName()) 1535 Out << "<<nameless>> = "; 1536 else { 1537 PrintLLVMName(Out, GA); 1538 Out << " = "; 1539 } 1540 PrintVisibility(GA->getVisibility(), Out); 1541 1542 Out << "alias "; 1543 1544 PrintLinkage(GA->getLinkage(), Out); 1545 1546 const Constant *Aliasee = GA->getAliasee(); 1547 1548 if (Aliasee == 0) { 1549 TypePrinter.print(GA->getType(), Out); 1550 Out << " <<NULL ALIASEE>>"; 1551 } else { 1552 writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee)); 1553 } 1554 1555 printInfoComment(*GA); 1556 Out << '\n'; 1557 } 1558 1559 void AssemblyWriter::printTypeIdentities() { 1560 if (TypePrinter.NumberedTypes.empty() && 1561 TypePrinter.NamedTypes.empty()) 1562 return; 1563 1564 Out << '\n'; 1565 1566 // We know all the numbers that each type is used and we know that it is a 1567 // dense assignment. Convert the map to an index table. 1568 std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size()); 1569 for (DenseMap<StructType*, unsigned>::iterator I = 1570 TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end(); 1571 I != E; ++I) { 1572 assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?"); 1573 NumberedTypes[I->second] = I->first; 1574 } 1575 1576 // Emit all numbered types. 1577 for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) { 1578 Out << '%' << i << " = type "; 1579 1580 // Make sure we print out at least one level of the type structure, so 1581 // that we do not get %2 = type %2 1582 TypePrinter.printStructBody(NumberedTypes[i], Out); 1583 Out << '\n'; 1584 } 1585 1586 for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) { 1587 PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix); 1588 Out << " = type "; 1589 1590 // Make sure we print out at least one level of the type structure, so 1591 // that we do not get %FILE = type %FILE 1592 TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out); 1593 Out << '\n'; 1594 } 1595 } 1596 1597 /// printFunction - Print all aspects of a function. 1598 /// 1599 void AssemblyWriter::printFunction(const Function *F) { 1600 // Print out the return type and name. 1601 Out << '\n'; 1602 1603 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 1604 1605 if (F->isMaterializable()) 1606 Out << "; Materializable\n"; 1607 1608 if (F->isDeclaration()) 1609 Out << "declare "; 1610 else 1611 Out << "define "; 1612 1613 PrintLinkage(F->getLinkage(), Out); 1614 PrintVisibility(F->getVisibility(), Out); 1615 1616 // Print the calling convention. 1617 if (F->getCallingConv() != CallingConv::C) { 1618 PrintCallingConv(F->getCallingConv(), Out); 1619 Out << " "; 1620 } 1621 1622 FunctionType *FT = F->getFunctionType(); 1623 const AttributeSet &Attrs = F->getAttributes(); 1624 if (Attrs.hasAttributes(AttributeSet::ReturnIndex)) 1625 Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' '; 1626 TypePrinter.print(F->getReturnType(), Out); 1627 Out << ' '; 1628 WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent()); 1629 Out << '('; 1630 Machine.incorporateFunction(F); 1631 1632 // Loop over the arguments, printing them... 1633 1634 unsigned Idx = 1; 1635 if (!F->isDeclaration()) { 1636 // If this isn't a declaration, print the argument names as well. 1637 for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 1638 I != E; ++I) { 1639 // Insert commas as we go... the first arg doesn't get a comma 1640 if (I != F->arg_begin()) Out << ", "; 1641 printArgument(I, Attrs, Idx); 1642 Idx++; 1643 } 1644 } else { 1645 // Otherwise, print the types from the function type. 1646 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 1647 // Insert commas as we go... the first arg doesn't get a comma 1648 if (i) Out << ", "; 1649 1650 // Output type... 1651 TypePrinter.print(FT->getParamType(i), Out); 1652 1653 if (Attrs.hasAttributes(i+1)) 1654 Out << ' ' << Attrs.getAsString(i+1); 1655 } 1656 } 1657 1658 // Finish printing arguments... 1659 if (FT->isVarArg()) { 1660 if (FT->getNumParams()) Out << ", "; 1661 Out << "..."; // Output varargs portion of signature! 1662 } 1663 Out << ')'; 1664 if (F->hasUnnamedAddr()) 1665 Out << " unnamed_addr"; 1666 if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) 1667 Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes()); 1668 if (F->hasSection()) { 1669 Out << " section \""; 1670 PrintEscapedString(F->getSection(), Out); 1671 Out << '"'; 1672 } 1673 if (F->getAlignment()) 1674 Out << " align " << F->getAlignment(); 1675 if (F->hasGC()) 1676 Out << " gc \"" << F->getGC() << '"'; 1677 if (F->isDeclaration()) { 1678 Out << '\n'; 1679 } else { 1680 Out << " {"; 1681 // Output all of the function's basic blocks. 1682 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 1683 printBasicBlock(I); 1684 1685 Out << "}\n"; 1686 } 1687 1688 Machine.purgeFunction(); 1689 } 1690 1691 /// printArgument - This member is called for every argument that is passed into 1692 /// the function. Simply print it out 1693 /// 1694 void AssemblyWriter::printArgument(const Argument *Arg, 1695 AttributeSet Attrs, unsigned Idx) { 1696 // Output type... 1697 TypePrinter.print(Arg->getType(), Out); 1698 1699 // Output parameter attributes list 1700 if (Attrs.hasAttributes(Idx)) 1701 Out << ' ' << Attrs.getAsString(Idx); 1702 1703 // Output name, if available... 1704 if (Arg->hasName()) { 1705 Out << ' '; 1706 PrintLLVMName(Out, Arg); 1707 } 1708 } 1709 1710 /// printBasicBlock - This member is called for each basic block in a method. 1711 /// 1712 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1713 if (BB->hasName()) { // Print out the label if it exists... 1714 Out << "\n"; 1715 PrintLLVMName(Out, BB->getName(), LabelPrefix); 1716 Out << ':'; 1717 } else if (!BB->use_empty()) { // Don't print block # of no uses... 1718 Out << "\n; <label>:"; 1719 int Slot = Machine.getLocalSlot(BB); 1720 if (Slot != -1) 1721 Out << Slot; 1722 else 1723 Out << "<badref>"; 1724 } 1725 1726 if (BB->getParent() == 0) { 1727 Out.PadToColumn(50); 1728 Out << "; Error: Block without parent!"; 1729 } else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block? 1730 // Output predecessors for the block. 1731 Out.PadToColumn(50); 1732 Out << ";"; 1733 const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB); 1734 1735 if (PI == PE) { 1736 Out << " No predecessors!"; 1737 } else { 1738 Out << " preds = "; 1739 writeOperand(*PI, false); 1740 for (++PI; PI != PE; ++PI) { 1741 Out << ", "; 1742 writeOperand(*PI, false); 1743 } 1744 } 1745 } 1746 1747 Out << "\n"; 1748 1749 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 1750 1751 // Output all of the instructions in the basic block... 1752 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 1753 printInstruction(*I); 1754 Out << '\n'; 1755 } 1756 1757 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1758 } 1759 1760 /// printInfoComment - Print a little comment after the instruction indicating 1761 /// which slot it occupies. 1762 /// 1763 void AssemblyWriter::printInfoComment(const Value &V) { 1764 if (AnnotationWriter) { 1765 AnnotationWriter->printInfoComment(V, Out); 1766 return; 1767 } 1768 } 1769 1770 // This member is called for each Instruction in a function.. 1771 void AssemblyWriter::printInstruction(const Instruction &I) { 1772 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 1773 1774 // Print out indentation for an instruction. 1775 Out << " "; 1776 1777 // Print out name if it exists... 1778 if (I.hasName()) { 1779 PrintLLVMName(Out, &I); 1780 Out << " = "; 1781 } else if (!I.getType()->isVoidTy()) { 1782 // Print out the def slot taken. 1783 int SlotNum = Machine.getLocalSlot(&I); 1784 if (SlotNum == -1) 1785 Out << "<badref> = "; 1786 else 1787 Out << '%' << SlotNum << " = "; 1788 } 1789 1790 if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) 1791 Out << "tail "; 1792 1793 // Print out the opcode... 1794 Out << I.getOpcodeName(); 1795 1796 // If this is an atomic load or store, print out the atomic marker. 1797 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) || 1798 (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic())) 1799 Out << " atomic"; 1800 1801 // If this is a volatile operation, print out the volatile marker. 1802 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1803 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) || 1804 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) || 1805 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile())) 1806 Out << " volatile"; 1807 1808 // Print out optimization information. 1809 WriteOptimizationInfo(Out, &I); 1810 1811 // Print out the compare instruction predicates 1812 if (const CmpInst *CI = dyn_cast<CmpInst>(&I)) 1813 Out << ' ' << getPredicateText(CI->getPredicate()); 1814 1815 // Print out the atomicrmw operation 1816 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) 1817 writeAtomicRMWOperation(Out, RMWI->getOperation()); 1818 1819 // Print out the type of the operands... 1820 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1821 1822 // Special case conditional branches to swizzle the condition out to the front 1823 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) { 1824 const BranchInst &BI(cast<BranchInst>(I)); 1825 Out << ' '; 1826 writeOperand(BI.getCondition(), true); 1827 Out << ", "; 1828 writeOperand(BI.getSuccessor(0), true); 1829 Out << ", "; 1830 writeOperand(BI.getSuccessor(1), true); 1831 1832 } else if (isa<SwitchInst>(I)) { 1833 const SwitchInst& SI(cast<SwitchInst>(I)); 1834 // Special case switch instruction to get formatting nice and correct. 1835 Out << ' '; 1836 writeOperand(SI.getCondition(), true); 1837 Out << ", "; 1838 writeOperand(SI.getDefaultDest(), true); 1839 Out << " ["; 1840 for (SwitchInst::ConstCaseIt i = SI.case_begin(), e = SI.case_end(); 1841 i != e; ++i) { 1842 Out << "\n "; 1843 writeOperand(i.getCaseValue(), true); 1844 Out << ", "; 1845 writeOperand(i.getCaseSuccessor(), true); 1846 } 1847 Out << "\n ]"; 1848 } else if (isa<IndirectBrInst>(I)) { 1849 // Special case indirectbr instruction to get formatting nice and correct. 1850 Out << ' '; 1851 writeOperand(Operand, true); 1852 Out << ", ["; 1853 1854 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 1855 if (i != 1) 1856 Out << ", "; 1857 writeOperand(I.getOperand(i), true); 1858 } 1859 Out << ']'; 1860 } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) { 1861 Out << ' '; 1862 TypePrinter.print(I.getType(), Out); 1863 Out << ' '; 1864 1865 for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) { 1866 if (op) Out << ", "; 1867 Out << "[ "; 1868 writeOperand(PN->getIncomingValue(op), false); Out << ", "; 1869 writeOperand(PN->getIncomingBlock(op), false); Out << " ]"; 1870 } 1871 } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) { 1872 Out << ' '; 1873 writeOperand(I.getOperand(0), true); 1874 for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i) 1875 Out << ", " << *i; 1876 } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) { 1877 Out << ' '; 1878 writeOperand(I.getOperand(0), true); Out << ", "; 1879 writeOperand(I.getOperand(1), true); 1880 for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i) 1881 Out << ", " << *i; 1882 } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) { 1883 Out << ' '; 1884 TypePrinter.print(I.getType(), Out); 1885 Out << " personality "; 1886 writeOperand(I.getOperand(0), true); Out << '\n'; 1887 1888 if (LPI->isCleanup()) 1889 Out << " cleanup"; 1890 1891 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) { 1892 if (i != 0 || LPI->isCleanup()) Out << "\n"; 1893 if (LPI->isCatch(i)) 1894 Out << " catch "; 1895 else 1896 Out << " filter "; 1897 1898 writeOperand(LPI->getClause(i), true); 1899 } 1900 } else if (isa<ReturnInst>(I) && !Operand) { 1901 Out << " void"; 1902 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1903 // Print the calling convention being used. 1904 if (CI->getCallingConv() != CallingConv::C) { 1905 Out << " "; 1906 PrintCallingConv(CI->getCallingConv(), Out); 1907 } 1908 1909 Operand = CI->getCalledValue(); 1910 PointerType *PTy = cast<PointerType>(Operand->getType()); 1911 FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1912 Type *RetTy = FTy->getReturnType(); 1913 const AttributeSet &PAL = CI->getAttributes(); 1914 1915 if (PAL.hasAttributes(AttributeSet::ReturnIndex)) 1916 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); 1917 1918 // If possible, print out the short form of the call instruction. We can 1919 // only do this if the first argument is a pointer to a nonvararg function, 1920 // and if the return type is not a pointer to a function. 1921 // 1922 Out << ' '; 1923 if (!FTy->isVarArg() && 1924 (!RetTy->isPointerTy() || 1925 !cast<PointerType>(RetTy)->getElementType()->isFunctionTy())) { 1926 TypePrinter.print(RetTy, Out); 1927 Out << ' '; 1928 writeOperand(Operand, false); 1929 } else { 1930 writeOperand(Operand, true); 1931 } 1932 Out << '('; 1933 for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) { 1934 if (op > 0) 1935 Out << ", "; 1936 writeParamOperand(CI->getArgOperand(op), PAL, op + 1); 1937 } 1938 Out << ')'; 1939 if (PAL.hasAttributes(AttributeSet::FunctionIndex)) 1940 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes()); 1941 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 1942 Operand = II->getCalledValue(); 1943 PointerType *PTy = cast<PointerType>(Operand->getType()); 1944 FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1945 Type *RetTy = FTy->getReturnType(); 1946 const AttributeSet &PAL = II->getAttributes(); 1947 1948 // Print the calling convention being used. 1949 if (II->getCallingConv() != CallingConv::C) { 1950 Out << " "; 1951 PrintCallingConv(II->getCallingConv(), Out); 1952 } 1953 1954 if (PAL.hasAttributes(AttributeSet::ReturnIndex)) 1955 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); 1956 1957 // If possible, print out the short form of the invoke instruction. We can 1958 // only do this if the first argument is a pointer to a nonvararg function, 1959 // and if the return type is not a pointer to a function. 1960 // 1961 Out << ' '; 1962 if (!FTy->isVarArg() && 1963 (!RetTy->isPointerTy() || 1964 !cast<PointerType>(RetTy)->getElementType()->isFunctionTy())) { 1965 TypePrinter.print(RetTy, Out); 1966 Out << ' '; 1967 writeOperand(Operand, false); 1968 } else { 1969 writeOperand(Operand, true); 1970 } 1971 Out << '('; 1972 for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) { 1973 if (op) 1974 Out << ", "; 1975 writeParamOperand(II->getArgOperand(op), PAL, op + 1); 1976 } 1977 1978 Out << ')'; 1979 if (PAL.hasAttributes(AttributeSet::FunctionIndex)) 1980 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes()); 1981 1982 Out << "\n to "; 1983 writeOperand(II->getNormalDest(), true); 1984 Out << " unwind "; 1985 writeOperand(II->getUnwindDest(), true); 1986 1987 } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) { 1988 Out << ' '; 1989 TypePrinter.print(AI->getAllocatedType(), Out); 1990 if (!AI->getArraySize() || AI->isArrayAllocation()) { 1991 Out << ", "; 1992 writeOperand(AI->getArraySize(), true); 1993 } 1994 if (AI->getAlignment()) { 1995 Out << ", align " << AI->getAlignment(); 1996 } 1997 } else if (isa<CastInst>(I)) { 1998 if (Operand) { 1999 Out << ' '; 2000 writeOperand(Operand, true); // Work with broken code 2001 } 2002 Out << " to "; 2003 TypePrinter.print(I.getType(), Out); 2004 } else if (isa<VAArgInst>(I)) { 2005 if (Operand) { 2006 Out << ' '; 2007 writeOperand(Operand, true); // Work with broken code 2008 } 2009 Out << ", "; 2010 TypePrinter.print(I.getType(), Out); 2011 } else if (Operand) { // Print the normal way. 2012 2013 // PrintAllTypes - Instructions who have operands of all the same type 2014 // omit the type from all but the first operand. If the instruction has 2015 // different type operands (for example br), then they are all printed. 2016 bool PrintAllTypes = false; 2017 Type *TheType = Operand->getType(); 2018 2019 // Select, Store and ShuffleVector always print all types. 2020 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I) 2021 || isa<ReturnInst>(I)) { 2022 PrintAllTypes = true; 2023 } else { 2024 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 2025 Operand = I.getOperand(i); 2026 // note that Operand shouldn't be null, but the test helps make dump() 2027 // more tolerant of malformed IR 2028 if (Operand && Operand->getType() != TheType) { 2029 PrintAllTypes = true; // We have differing types! Print them all! 2030 break; 2031 } 2032 } 2033 } 2034 2035 if (!PrintAllTypes) { 2036 Out << ' '; 2037 TypePrinter.print(TheType, Out); 2038 } 2039 2040 Out << ' '; 2041 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 2042 if (i) Out << ", "; 2043 writeOperand(I.getOperand(i), PrintAllTypes); 2044 } 2045 } 2046 2047 // Print atomic ordering/alignment for memory operations 2048 if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) { 2049 if (LI->isAtomic()) 2050 writeAtomic(LI->getOrdering(), LI->getSynchScope()); 2051 if (LI->getAlignment()) 2052 Out << ", align " << LI->getAlignment(); 2053 } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) { 2054 if (SI->isAtomic()) 2055 writeAtomic(SI->getOrdering(), SI->getSynchScope()); 2056 if (SI->getAlignment()) 2057 Out << ", align " << SI->getAlignment(); 2058 } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) { 2059 writeAtomic(CXI->getOrdering(), CXI->getSynchScope()); 2060 } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) { 2061 writeAtomic(RMWI->getOrdering(), RMWI->getSynchScope()); 2062 } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) { 2063 writeAtomic(FI->getOrdering(), FI->getSynchScope()); 2064 } 2065 2066 // Print Metadata info. 2067 SmallVector<std::pair<unsigned, MDNode*>, 4> InstMD; 2068 I.getAllMetadata(InstMD); 2069 if (!InstMD.empty()) { 2070 SmallVector<StringRef, 8> MDNames; 2071 I.getType()->getContext().getMDKindNames(MDNames); 2072 for (unsigned i = 0, e = InstMD.size(); i != e; ++i) { 2073 unsigned Kind = InstMD[i].first; 2074 if (Kind < MDNames.size()) { 2075 Out << ", !" << MDNames[Kind]; 2076 } else { 2077 Out << ", !<unknown kind #" << Kind << ">"; 2078 } 2079 Out << ' '; 2080 WriteAsOperandInternal(Out, InstMD[i].second, &TypePrinter, &Machine, 2081 TheModule); 2082 } 2083 } 2084 printInfoComment(I); 2085 } 2086 2087 static void WriteMDNodeComment(const MDNode *Node, 2088 formatted_raw_ostream &Out) { 2089 if (Node->getNumOperands() < 1) 2090 return; 2091 2092 Value *Op = Node->getOperand(0); 2093 if (!Op || !isa<ConstantInt>(Op) || cast<ConstantInt>(Op)->getBitWidth() < 32) 2094 return; 2095 2096 DIDescriptor Desc(Node); 2097 if (!Desc.Verify()) 2098 return; 2099 2100 unsigned Tag = Desc.getTag(); 2101 Out.PadToColumn(50); 2102 if (dwarf::TagString(Tag)) { 2103 Out << "; "; 2104 Desc.print(Out); 2105 } else if (Tag == dwarf::DW_TAG_user_base) { 2106 Out << "; [ DW_TAG_user_base ]"; 2107 } 2108 } 2109 2110 void AssemblyWriter::writeAllMDNodes() { 2111 SmallVector<const MDNode *, 16> Nodes; 2112 Nodes.resize(Machine.mdn_size()); 2113 for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end(); 2114 I != E; ++I) 2115 Nodes[I->second] = cast<MDNode>(I->first); 2116 2117 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 2118 Out << '!' << i << " = metadata "; 2119 printMDNodeBody(Nodes[i]); 2120 } 2121 } 2122 2123 void AssemblyWriter::printMDNodeBody(const MDNode *Node) { 2124 WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule); 2125 WriteMDNodeComment(Node, Out); 2126 Out << "\n"; 2127 } 2128 2129 void AssemblyWriter::writeAllAttributeGroups() { 2130 std::vector<std::pair<AttributeSet, unsigned> > asVec; 2131 asVec.resize(Machine.as_size()); 2132 2133 for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end(); 2134 I != E; ++I) 2135 asVec[I->second] = *I; 2136 2137 for (std::vector<std::pair<AttributeSet, unsigned> >::iterator 2138 I = asVec.begin(), E = asVec.end(); I != E; ++I) 2139 Out << "attributes #" << I->second << " = { " 2140 << I->first.getAsString(AttributeSet::FunctionIndex, true) << " }\n"; 2141 } 2142 2143 //===----------------------------------------------------------------------===// 2144 // External Interface declarations 2145 //===----------------------------------------------------------------------===// 2146 2147 void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2148 SlotTracker SlotTable(this); 2149 formatted_raw_ostream OS(ROS); 2150 AssemblyWriter W(OS, SlotTable, this, AAW); 2151 W.printModule(this); 2152 } 2153 2154 void NamedMDNode::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2155 SlotTracker SlotTable(getParent()); 2156 formatted_raw_ostream OS(ROS); 2157 AssemblyWriter W(OS, SlotTable, getParent(), AAW); 2158 W.printNamedMDNode(this); 2159 } 2160 2161 void Type::print(raw_ostream &OS) const { 2162 if (this == 0) { 2163 OS << "<null Type>"; 2164 return; 2165 } 2166 TypePrinting TP; 2167 TP.print(const_cast<Type*>(this), OS); 2168 2169 // If the type is a named struct type, print the body as well. 2170 if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this))) 2171 if (!STy->isLiteral()) { 2172 OS << " = type "; 2173 TP.printStructBody(STy, OS); 2174 } 2175 } 2176 2177 void Value::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2178 if (this == 0) { 2179 ROS << "printing a <null> value\n"; 2180 return; 2181 } 2182 formatted_raw_ostream OS(ROS); 2183 if (const Instruction *I = dyn_cast<Instruction>(this)) { 2184 const Function *F = I->getParent() ? I->getParent()->getParent() : 0; 2185 SlotTracker SlotTable(F); 2186 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), AAW); 2187 W.printInstruction(*I); 2188 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) { 2189 SlotTracker SlotTable(BB->getParent()); 2190 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), AAW); 2191 W.printBasicBlock(BB); 2192 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) { 2193 SlotTracker SlotTable(GV->getParent()); 2194 AssemblyWriter W(OS, SlotTable, GV->getParent(), AAW); 2195 if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV)) 2196 W.printGlobal(V); 2197 else if (const Function *F = dyn_cast<Function>(GV)) 2198 W.printFunction(F); 2199 else 2200 W.printAlias(cast<GlobalAlias>(GV)); 2201 } else if (const MDNode *N = dyn_cast<MDNode>(this)) { 2202 const Function *F = N->getFunction(); 2203 SlotTracker SlotTable(F); 2204 AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW); 2205 W.printMDNodeBody(N); 2206 } else if (const Constant *C = dyn_cast<Constant>(this)) { 2207 TypePrinting TypePrinter; 2208 TypePrinter.print(C->getType(), OS); 2209 OS << ' '; 2210 WriteConstantInternal(OS, C, TypePrinter, 0, 0); 2211 } else if (isa<InlineAsm>(this) || isa<MDString>(this) || 2212 isa<Argument>(this)) { 2213 WriteAsOperand(OS, this, true, 0); 2214 } else { 2215 // Otherwise we don't know what it is. Call the virtual function to 2216 // allow a subclass to print itself. 2217 printCustom(OS); 2218 } 2219 } 2220 2221 // Value::printCustom - subclasses should override this to implement printing. 2222 void Value::printCustom(raw_ostream &OS) const { 2223 llvm_unreachable("Unknown value to print out!"); 2224 } 2225 2226 // Value::dump - allow easy printing of Values from the debugger. 2227 void Value::dump() const { print(dbgs()); dbgs() << '\n'; } 2228 2229 // Type::dump - allow easy printing of Types from the debugger. 2230 void Type::dump() const { print(dbgs()); } 2231 2232 // Module::dump() - Allow printing of Modules from the debugger. 2233 void Module::dump() const { print(dbgs(), 0); } 2234 2235 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger. 2236 void NamedMDNode::dump() const { print(dbgs(), 0); } 2237