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