AsmWriter.cpp revision d3da6d5dda00761d383a1c339f54da470643c663
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> 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 FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) { 707 // Unsafe algebra implies all the others, no need to write them all out 708 if (FPO->hasUnsafeAlgebra()) 709 Out << " fast"; 710 else { 711 if (FPO->hasNoNaNs()) 712 Out << " nnan"; 713 if (FPO->hasNoInfs()) 714 Out << " ninf"; 715 if (FPO->hasNoSignedZeros()) 716 Out << " nsz"; 717 if (FPO->hasAllowReciprocal()) 718 Out << " arcp"; 719 } 720 } 721 722 if (const OverflowingBinaryOperator *OBO = 723 dyn_cast<OverflowingBinaryOperator>(U)) { 724 if (OBO->hasNoUnsignedWrap()) 725 Out << " nuw"; 726 if (OBO->hasNoSignedWrap()) 727 Out << " nsw"; 728 } else if (const PossiblyExactOperator *Div = 729 dyn_cast<PossiblyExactOperator>(U)) { 730 if (Div->isExact()) 731 Out << " exact"; 732 } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) { 733 if (GEP->isInBounds()) 734 Out << " inbounds"; 735 } 736} 737 738static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, 739 TypePrinting &TypePrinter, 740 SlotTracker *Machine, 741 const Module *Context) { 742 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 743 if (CI->getType()->isIntegerTy(1)) { 744 Out << (CI->getZExtValue() ? "true" : "false"); 745 return; 746 } 747 Out << CI->getValue(); 748 return; 749 } 750 751 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { 752 if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle || 753 &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble) { 754 // We would like to output the FP constant value in exponential notation, 755 // but we cannot do this if doing so will lose precision. Check here to 756 // make sure that we only output it in exponential format if we can parse 757 // the value back and get the same value. 758 // 759 bool ignored; 760 bool isHalf = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEhalf; 761 bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble; 762 bool isInf = CFP->getValueAPF().isInfinity(); 763 bool isNaN = CFP->getValueAPF().isNaN(); 764 if (!isHalf && !isInf && !isNaN) { 765 double Val = isDouble ? CFP->getValueAPF().convertToDouble() : 766 CFP->getValueAPF().convertToFloat(); 767 SmallString<128> StrVal; 768 raw_svector_ostream(StrVal) << Val; 769 770 // Check to make sure that the stringized number is not some string like 771 // "Inf" or NaN, that atof will accept, but the lexer will not. Check 772 // that the string matches the "[-+]?[0-9]" regex. 773 // 774 if ((StrVal[0] >= '0' && StrVal[0] <= '9') || 775 ((StrVal[0] == '-' || StrVal[0] == '+') && 776 (StrVal[1] >= '0' && StrVal[1] <= '9'))) { 777 // Reparse stringized version! 778 if (APFloat(APFloat::IEEEdouble, StrVal).convertToDouble() == Val) { 779 Out << StrVal.str(); 780 return; 781 } 782 } 783 } 784 // Otherwise we could not reparse it to exactly the same value, so we must 785 // output the string in hexadecimal format! Note that loading and storing 786 // floating point types changes the bits of NaNs on some hosts, notably 787 // x86, so we must not use these types. 788 assert(sizeof(double) == sizeof(uint64_t) && 789 "assuming that double is 64 bits!"); 790 char Buffer[40]; 791 APFloat apf = CFP->getValueAPF(); 792 // Halves and floats are represented in ASCII IR as double, convert. 793 if (!isDouble) 794 apf.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 795 &ignored); 796 Out << "0x" << 797 utohex_buffer(uint64_t(apf.bitcastToAPInt().getZExtValue()), 798 Buffer+40); 799 return; 800 } 801 802 // Either half, or some form of long double. 803 // These appear as a magic letter identifying the type, then a 804 // fixed number of hex digits. 805 Out << "0x"; 806 // Bit position, in the current word, of the next nibble to print. 807 int shiftcount; 808 809 if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended) { 810 Out << 'K'; 811 // api needed to prevent premature destruction 812 APInt api = CFP->getValueAPF().bitcastToAPInt(); 813 const uint64_t* p = api.getRawData(); 814 uint64_t word = p[1]; 815 shiftcount = 12; 816 int width = api.getBitWidth(); 817 for (int j=0; j<width; j+=4, shiftcount-=4) { 818 unsigned int nibble = (word>>shiftcount) & 15; 819 if (nibble < 10) 820 Out << (unsigned char)(nibble + '0'); 821 else 822 Out << (unsigned char)(nibble - 10 + 'A'); 823 if (shiftcount == 0 && j+4 < width) { 824 word = *p; 825 shiftcount = 64; 826 if (width-j-4 < 64) 827 shiftcount = width-j-4; 828 } 829 } 830 return; 831 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad) { 832 shiftcount = 60; 833 Out << 'L'; 834 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble) { 835 shiftcount = 60; 836 Out << 'M'; 837 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEhalf) { 838 shiftcount = 12; 839 Out << 'H'; 840 } else 841 llvm_unreachable("Unsupported floating point type"); 842 // api needed to prevent premature destruction 843 APInt api = CFP->getValueAPF().bitcastToAPInt(); 844 const uint64_t* p = api.getRawData(); 845 uint64_t word = *p; 846 int width = api.getBitWidth(); 847 for (int j=0; j<width; j+=4, shiftcount-=4) { 848 unsigned int nibble = (word>>shiftcount) & 15; 849 if (nibble < 10) 850 Out << (unsigned char)(nibble + '0'); 851 else 852 Out << (unsigned char)(nibble - 10 + 'A'); 853 if (shiftcount == 0 && j+4 < width) { 854 word = *(++p); 855 shiftcount = 64; 856 if (width-j-4 < 64) 857 shiftcount = width-j-4; 858 } 859 } 860 return; 861 } 862 863 if (isa<ConstantAggregateZero>(CV)) { 864 Out << "zeroinitializer"; 865 return; 866 } 867 868 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) { 869 Out << "blockaddress("; 870 WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine, 871 Context); 872 Out << ", "; 873 WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine, 874 Context); 875 Out << ")"; 876 return; 877 } 878 879 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) { 880 Type *ETy = CA->getType()->getElementType(); 881 Out << '['; 882 TypePrinter.print(ETy, Out); 883 Out << ' '; 884 WriteAsOperandInternal(Out, CA->getOperand(0), 885 &TypePrinter, Machine, 886 Context); 887 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { 888 Out << ", "; 889 TypePrinter.print(ETy, Out); 890 Out << ' '; 891 WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine, 892 Context); 893 } 894 Out << ']'; 895 return; 896 } 897 898 if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) { 899 // As a special case, print the array as a string if it is an array of 900 // i8 with ConstantInt values. 901 if (CA->isString()) { 902 Out << "c\""; 903 PrintEscapedString(CA->getAsString(), Out); 904 Out << '"'; 905 return; 906 } 907 908 Type *ETy = CA->getType()->getElementType(); 909 Out << '['; 910 TypePrinter.print(ETy, Out); 911 Out << ' '; 912 WriteAsOperandInternal(Out, CA->getElementAsConstant(0), 913 &TypePrinter, Machine, 914 Context); 915 for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) { 916 Out << ", "; 917 TypePrinter.print(ETy, Out); 918 Out << ' '; 919 WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter, 920 Machine, Context); 921 } 922 Out << ']'; 923 return; 924 } 925 926 927 if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) { 928 if (CS->getType()->isPacked()) 929 Out << '<'; 930 Out << '{'; 931 unsigned N = CS->getNumOperands(); 932 if (N) { 933 Out << ' '; 934 TypePrinter.print(CS->getOperand(0)->getType(), Out); 935 Out << ' '; 936 937 WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine, 938 Context); 939 940 for (unsigned i = 1; i < N; i++) { 941 Out << ", "; 942 TypePrinter.print(CS->getOperand(i)->getType(), Out); 943 Out << ' '; 944 945 WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine, 946 Context); 947 } 948 Out << ' '; 949 } 950 951 Out << '}'; 952 if (CS->getType()->isPacked()) 953 Out << '>'; 954 return; 955 } 956 957 if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) { 958 Type *ETy = CV->getType()->getVectorElementType(); 959 Out << '<'; 960 TypePrinter.print(ETy, Out); 961 Out << ' '; 962 WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter, 963 Machine, Context); 964 for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){ 965 Out << ", "; 966 TypePrinter.print(ETy, Out); 967 Out << ' '; 968 WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter, 969 Machine, Context); 970 } 971 Out << '>'; 972 return; 973 } 974 975 if (isa<ConstantPointerNull>(CV)) { 976 Out << "null"; 977 return; 978 } 979 980 if (isa<UndefValue>(CV)) { 981 Out << "undef"; 982 return; 983 } 984 985 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 986 Out << CE->getOpcodeName(); 987 WriteOptimizationInfo(Out, CE); 988 if (CE->isCompare()) 989 Out << ' ' << getPredicateText(CE->getPredicate()); 990 Out << " ("; 991 992 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { 993 TypePrinter.print((*OI)->getType(), Out); 994 Out << ' '; 995 WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context); 996 if (OI+1 != CE->op_end()) 997 Out << ", "; 998 } 999 1000 if (CE->hasIndices()) { 1001 ArrayRef<unsigned> Indices = CE->getIndices(); 1002 for (unsigned i = 0, e = Indices.size(); i != e; ++i) 1003 Out << ", " << Indices[i]; 1004 } 1005 1006 if (CE->isCast()) { 1007 Out << " to "; 1008 TypePrinter.print(CE->getType(), Out); 1009 } 1010 1011 Out << ')'; 1012 return; 1013 } 1014 1015 Out << "<placeholder or erroneous Constant>"; 1016} 1017 1018static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, 1019 TypePrinting *TypePrinter, 1020 SlotTracker *Machine, 1021 const Module *Context) { 1022 Out << "!{"; 1023 for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) { 1024 const Value *V = Node->getOperand(mi); 1025 if (V == 0) 1026 Out << "null"; 1027 else { 1028 TypePrinter->print(V->getType(), Out); 1029 Out << ' '; 1030 WriteAsOperandInternal(Out, Node->getOperand(mi), 1031 TypePrinter, Machine, Context); 1032 } 1033 if (mi + 1 != me) 1034 Out << ", "; 1035 } 1036 1037 Out << "}"; 1038} 1039 1040 1041/// WriteAsOperand - Write the name of the specified value out to the specified 1042/// ostream. This can be useful when you just want to print int %reg126, not 1043/// the whole instruction that generated it. 1044/// 1045static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, 1046 TypePrinting *TypePrinter, 1047 SlotTracker *Machine, 1048 const Module *Context) { 1049 if (V->hasName()) { 1050 PrintLLVMName(Out, V); 1051 return; 1052 } 1053 1054 const Constant *CV = dyn_cast<Constant>(V); 1055 if (CV && !isa<GlobalValue>(CV)) { 1056 assert(TypePrinter && "Constants require TypePrinting!"); 1057 WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context); 1058 return; 1059 } 1060 1061 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { 1062 Out << "asm "; 1063 if (IA->hasSideEffects()) 1064 Out << "sideeffect "; 1065 if (IA->isAlignStack()) 1066 Out << "alignstack "; 1067 // We don't emit the AD_ATT dialect as it's the assumed default. 1068 if (IA->getDialect() == InlineAsm::AD_Intel) 1069 Out << "inteldialect "; 1070 Out << '"'; 1071 PrintEscapedString(IA->getAsmString(), Out); 1072 Out << "\", \""; 1073 PrintEscapedString(IA->getConstraintString(), Out); 1074 Out << '"'; 1075 return; 1076 } 1077 1078 if (const MDNode *N = dyn_cast<MDNode>(V)) { 1079 if (N->isFunctionLocal()) { 1080 // Print metadata inline, not via slot reference number. 1081 WriteMDNodeBodyInternal(Out, N, TypePrinter, Machine, Context); 1082 return; 1083 } 1084 1085 if (!Machine) { 1086 if (N->isFunctionLocal()) 1087 Machine = new SlotTracker(N->getFunction()); 1088 else 1089 Machine = new SlotTracker(Context); 1090 } 1091 int Slot = Machine->getMetadataSlot(N); 1092 if (Slot == -1) 1093 Out << "<badref>"; 1094 else 1095 Out << '!' << Slot; 1096 return; 1097 } 1098 1099 if (const MDString *MDS = dyn_cast<MDString>(V)) { 1100 Out << "!\""; 1101 PrintEscapedString(MDS->getString(), Out); 1102 Out << '"'; 1103 return; 1104 } 1105 1106 if (V->getValueID() == Value::PseudoSourceValueVal || 1107 V->getValueID() == Value::FixedStackPseudoSourceValueVal) { 1108 V->print(Out); 1109 return; 1110 } 1111 1112 char Prefix = '%'; 1113 int Slot; 1114 // If we have a SlotTracker, use it. 1115 if (Machine) { 1116 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1117 Slot = Machine->getGlobalSlot(GV); 1118 Prefix = '@'; 1119 } else { 1120 Slot = Machine->getLocalSlot(V); 1121 1122 // If the local value didn't succeed, then we may be referring to a value 1123 // from a different function. Translate it, as this can happen when using 1124 // address of blocks. 1125 if (Slot == -1) 1126 if ((Machine = createSlotTracker(V))) { 1127 Slot = Machine->getLocalSlot(V); 1128 delete Machine; 1129 } 1130 } 1131 } else if ((Machine = createSlotTracker(V))) { 1132 // Otherwise, create one to get the # and then destroy it. 1133 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1134 Slot = Machine->getGlobalSlot(GV); 1135 Prefix = '@'; 1136 } else { 1137 Slot = Machine->getLocalSlot(V); 1138 } 1139 delete Machine; 1140 Machine = 0; 1141 } else { 1142 Slot = -1; 1143 } 1144 1145 if (Slot != -1) 1146 Out << Prefix << Slot; 1147 else 1148 Out << "<badref>"; 1149} 1150 1151void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, 1152 bool PrintType, const Module *Context) { 1153 1154 // Fast path: Don't construct and populate a TypePrinting object if we 1155 // won't be needing any types printed. 1156 if (!PrintType && 1157 ((!isa<Constant>(V) && !isa<MDNode>(V)) || 1158 V->hasName() || isa<GlobalValue>(V))) { 1159 WriteAsOperandInternal(Out, V, 0, 0, Context); 1160 return; 1161 } 1162 1163 if (Context == 0) Context = getModuleFromVal(V); 1164 1165 TypePrinting TypePrinter; 1166 if (Context) 1167 TypePrinter.incorporateTypes(*Context); 1168 if (PrintType) { 1169 TypePrinter.print(V->getType(), Out); 1170 Out << ' '; 1171 } 1172 1173 WriteAsOperandInternal(Out, V, &TypePrinter, 0, Context); 1174} 1175 1176namespace { 1177 1178class AssemblyWriter { 1179 formatted_raw_ostream &Out; 1180 SlotTracker &Machine; 1181 const Module *TheModule; 1182 TypePrinting TypePrinter; 1183 AssemblyAnnotationWriter *AnnotationWriter; 1184 1185public: 1186 inline AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, 1187 const Module *M, 1188 AssemblyAnnotationWriter *AAW) 1189 : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) { 1190 if (M) 1191 TypePrinter.incorporateTypes(*M); 1192 } 1193 1194 void printMDNodeBody(const MDNode *MD); 1195 void printNamedMDNode(const NamedMDNode *NMD); 1196 1197 void printModule(const Module *M); 1198 1199 void writeOperand(const Value *Op, bool PrintType); 1200 void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx); 1201 void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope); 1202 1203 void writeAllMDNodes(); 1204 1205 void printTypeIdentities(); 1206 void printGlobal(const GlobalVariable *GV); 1207 void printAlias(const GlobalAlias *GV); 1208 void printFunction(const Function *F); 1209 void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx); 1210 void printBasicBlock(const BasicBlock *BB); 1211 void printInstruction(const Instruction &I); 1212 1213private: 1214 // printInfoComment - Print a little comment after the instruction indicating 1215 // which slot it occupies. 1216 void printInfoComment(const Value &V); 1217}; 1218} // end of anonymous namespace 1219 1220void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { 1221 if (Operand == 0) { 1222 Out << "<null operand!>"; 1223 return; 1224 } 1225 if (PrintType) { 1226 TypePrinter.print(Operand->getType(), Out); 1227 Out << ' '; 1228 } 1229 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); 1230} 1231 1232void AssemblyWriter::writeAtomic(AtomicOrdering Ordering, 1233 SynchronizationScope SynchScope) { 1234 if (Ordering == NotAtomic) 1235 return; 1236 1237 switch (SynchScope) { 1238 case SingleThread: Out << " singlethread"; break; 1239 case CrossThread: break; 1240 } 1241 1242 switch (Ordering) { 1243 default: Out << " <bad ordering " << int(Ordering) << ">"; break; 1244 case Unordered: Out << " unordered"; break; 1245 case Monotonic: Out << " monotonic"; break; 1246 case Acquire: Out << " acquire"; break; 1247 case Release: Out << " release"; break; 1248 case AcquireRelease: Out << " acq_rel"; break; 1249 case SequentiallyConsistent: Out << " seq_cst"; break; 1250 } 1251} 1252 1253void AssemblyWriter::writeParamOperand(const Value *Operand, 1254 AttributeSet Attrs, unsigned Idx) { 1255 if (Operand == 0) { 1256 Out << "<null operand!>"; 1257 return; 1258 } 1259 1260 // Print the type 1261 TypePrinter.print(Operand->getType(), Out); 1262 // Print parameter attributes list 1263 if (Attrs.hasAttributes(Idx)) 1264 Out << ' ' << Attrs.getAsString(Idx); 1265 Out << ' '; 1266 // Print the operand 1267 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule); 1268} 1269 1270void AssemblyWriter::printModule(const Module *M) { 1271 if (!M->getModuleIdentifier().empty() && 1272 // Don't print the ID if it will start a new line (which would 1273 // require a comment char before it). 1274 M->getModuleIdentifier().find('\n') == std::string::npos) 1275 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n"; 1276 1277 if (!M->getDataLayout().empty()) 1278 Out << "target datalayout = \"" << M->getDataLayout() << "\"\n"; 1279 if (!M->getTargetTriple().empty()) 1280 Out << "target triple = \"" << M->getTargetTriple() << "\"\n"; 1281 1282 if (!M->getModuleInlineAsm().empty()) { 1283 // Split the string into lines, to make it easier to read the .ll file. 1284 std::string Asm = M->getModuleInlineAsm(); 1285 size_t CurPos = 0; 1286 size_t NewLine = Asm.find_first_of('\n', CurPos); 1287 Out << '\n'; 1288 while (NewLine != std::string::npos) { 1289 // We found a newline, print the portion of the asm string from the 1290 // last newline up to this newline. 1291 Out << "module asm \""; 1292 PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), 1293 Out); 1294 Out << "\"\n"; 1295 CurPos = NewLine+1; 1296 NewLine = Asm.find_first_of('\n', CurPos); 1297 } 1298 std::string rest(Asm.begin()+CurPos, Asm.end()); 1299 if (!rest.empty()) { 1300 Out << "module asm \""; 1301 PrintEscapedString(rest, Out); 1302 Out << "\"\n"; 1303 } 1304 } 1305 1306 printTypeIdentities(); 1307 1308 // Output all globals. 1309 if (!M->global_empty()) Out << '\n'; 1310 for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); 1311 I != E; ++I) { 1312 printGlobal(I); Out << '\n'; 1313 } 1314 1315 // Output all aliases. 1316 if (!M->alias_empty()) Out << "\n"; 1317 for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 1318 I != E; ++I) 1319 printAlias(I); 1320 1321 // Output all of the functions. 1322 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 1323 printFunction(I); 1324 1325 // Output named metadata. 1326 if (!M->named_metadata_empty()) Out << '\n'; 1327 1328 for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), 1329 E = M->named_metadata_end(); I != E; ++I) 1330 printNamedMDNode(I); 1331 1332 // Output metadata. 1333 if (!Machine.mdn_empty()) { 1334 Out << '\n'; 1335 writeAllMDNodes(); 1336 } 1337} 1338 1339void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) { 1340 Out << '!'; 1341 StringRef Name = NMD->getName(); 1342 if (Name.empty()) { 1343 Out << "<empty name> "; 1344 } else { 1345 if (isalpha(Name[0]) || Name[0] == '-' || Name[0] == '$' || 1346 Name[0] == '.' || Name[0] == '_') 1347 Out << Name[0]; 1348 else 1349 Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F); 1350 for (unsigned i = 1, e = Name.size(); i != e; ++i) { 1351 unsigned char C = Name[i]; 1352 if (isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_') 1353 Out << C; 1354 else 1355 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F); 1356 } 1357 } 1358 Out << " = !{"; 1359 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 1360 if (i) Out << ", "; 1361 int Slot = Machine.getMetadataSlot(NMD->getOperand(i)); 1362 if (Slot == -1) 1363 Out << "<badref>"; 1364 else 1365 Out << '!' << Slot; 1366 } 1367 Out << "}\n"; 1368} 1369 1370 1371static void PrintLinkage(GlobalValue::LinkageTypes LT, 1372 formatted_raw_ostream &Out) { 1373 switch (LT) { 1374 case GlobalValue::ExternalLinkage: break; 1375 case GlobalValue::PrivateLinkage: Out << "private "; break; 1376 case GlobalValue::LinkerPrivateLinkage: Out << "linker_private "; break; 1377 case GlobalValue::LinkerPrivateWeakLinkage: 1378 Out << "linker_private_weak "; 1379 break; 1380 case GlobalValue::InternalLinkage: Out << "internal "; break; 1381 case GlobalValue::LinkOnceAnyLinkage: Out << "linkonce "; break; 1382 case GlobalValue::LinkOnceODRLinkage: Out << "linkonce_odr "; break; 1383 case GlobalValue::LinkOnceODRAutoHideLinkage: 1384 Out << "linkonce_odr_auto_hide "; 1385 break; 1386 case GlobalValue::WeakAnyLinkage: Out << "weak "; break; 1387 case GlobalValue::WeakODRLinkage: Out << "weak_odr "; break; 1388 case GlobalValue::CommonLinkage: Out << "common "; break; 1389 case GlobalValue::AppendingLinkage: Out << "appending "; break; 1390 case GlobalValue::DLLImportLinkage: Out << "dllimport "; break; 1391 case GlobalValue::DLLExportLinkage: Out << "dllexport "; break; 1392 case GlobalValue::ExternalWeakLinkage: Out << "extern_weak "; break; 1393 case GlobalValue::AvailableExternallyLinkage: 1394 Out << "available_externally "; 1395 break; 1396 } 1397} 1398 1399 1400static void PrintVisibility(GlobalValue::VisibilityTypes Vis, 1401 formatted_raw_ostream &Out) { 1402 switch (Vis) { 1403 case GlobalValue::DefaultVisibility: break; 1404 case GlobalValue::HiddenVisibility: Out << "hidden "; break; 1405 case GlobalValue::ProtectedVisibility: Out << "protected "; break; 1406 } 1407} 1408 1409static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, 1410 formatted_raw_ostream &Out) { 1411 switch (TLM) { 1412 case GlobalVariable::NotThreadLocal: 1413 break; 1414 case GlobalVariable::GeneralDynamicTLSModel: 1415 Out << "thread_local "; 1416 break; 1417 case GlobalVariable::LocalDynamicTLSModel: 1418 Out << "thread_local(localdynamic) "; 1419 break; 1420 case GlobalVariable::InitialExecTLSModel: 1421 Out << "thread_local(initialexec) "; 1422 break; 1423 case GlobalVariable::LocalExecTLSModel: 1424 Out << "thread_local(localexec) "; 1425 break; 1426 } 1427} 1428 1429void AssemblyWriter::printGlobal(const GlobalVariable *GV) { 1430 if (GV->isMaterializable()) 1431 Out << "; Materializable\n"; 1432 1433 WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent()); 1434 Out << " = "; 1435 1436 if (!GV->hasInitializer() && GV->hasExternalLinkage()) 1437 Out << "external "; 1438 1439 PrintLinkage(GV->getLinkage(), Out); 1440 PrintVisibility(GV->getVisibility(), Out); 1441 PrintThreadLocalModel(GV->getThreadLocalMode(), Out); 1442 1443 if (unsigned AddressSpace = GV->getType()->getAddressSpace()) 1444 Out << "addrspace(" << AddressSpace << ") "; 1445 if (GV->hasUnnamedAddr()) Out << "unnamed_addr "; 1446 if (GV->isExternallyInitialized()) Out << "externally_initialized "; 1447 Out << (GV->isConstant() ? "constant " : "global "); 1448 TypePrinter.print(GV->getType()->getElementType(), Out); 1449 1450 if (GV->hasInitializer()) { 1451 Out << ' '; 1452 writeOperand(GV->getInitializer(), false); 1453 } 1454 1455 if (GV->hasSection()) { 1456 Out << ", section \""; 1457 PrintEscapedString(GV->getSection(), Out); 1458 Out << '"'; 1459 } 1460 if (GV->getAlignment()) 1461 Out << ", align " << GV->getAlignment(); 1462 1463 printInfoComment(*GV); 1464} 1465 1466void AssemblyWriter::printAlias(const GlobalAlias *GA) { 1467 if (GA->isMaterializable()) 1468 Out << "; Materializable\n"; 1469 1470 // Don't crash when dumping partially built GA 1471 if (!GA->hasName()) 1472 Out << "<<nameless>> = "; 1473 else { 1474 PrintLLVMName(Out, GA); 1475 Out << " = "; 1476 } 1477 PrintVisibility(GA->getVisibility(), Out); 1478 1479 Out << "alias "; 1480 1481 PrintLinkage(GA->getLinkage(), Out); 1482 1483 const Constant *Aliasee = GA->getAliasee(); 1484 1485 if (Aliasee == 0) { 1486 TypePrinter.print(GA->getType(), Out); 1487 Out << " <<NULL ALIASEE>>"; 1488 } else { 1489 writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee)); 1490 } 1491 1492 printInfoComment(*GA); 1493 Out << '\n'; 1494} 1495 1496void AssemblyWriter::printTypeIdentities() { 1497 if (TypePrinter.NumberedTypes.empty() && 1498 TypePrinter.NamedTypes.empty()) 1499 return; 1500 1501 Out << '\n'; 1502 1503 // We know all the numbers that each type is used and we know that it is a 1504 // dense assignment. Convert the map to an index table. 1505 std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size()); 1506 for (DenseMap<StructType*, unsigned>::iterator I = 1507 TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end(); 1508 I != E; ++I) { 1509 assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?"); 1510 NumberedTypes[I->second] = I->first; 1511 } 1512 1513 // Emit all numbered types. 1514 for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) { 1515 Out << '%' << i << " = type "; 1516 1517 // Make sure we print out at least one level of the type structure, so 1518 // that we do not get %2 = type %2 1519 TypePrinter.printStructBody(NumberedTypes[i], Out); 1520 Out << '\n'; 1521 } 1522 1523 for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) { 1524 PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix); 1525 Out << " = type "; 1526 1527 // Make sure we print out at least one level of the type structure, so 1528 // that we do not get %FILE = type %FILE 1529 TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out); 1530 Out << '\n'; 1531 } 1532} 1533 1534/// printFunction - Print all aspects of a function. 1535/// 1536void AssemblyWriter::printFunction(const Function *F) { 1537 // Print out the return type and name. 1538 Out << '\n'; 1539 1540 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out); 1541 1542 if (F->isMaterializable()) 1543 Out << "; Materializable\n"; 1544 1545 if (F->isDeclaration()) 1546 Out << "declare "; 1547 else 1548 Out << "define "; 1549 1550 PrintLinkage(F->getLinkage(), Out); 1551 PrintVisibility(F->getVisibility(), Out); 1552 1553 // Print the calling convention. 1554 if (F->getCallingConv() != CallingConv::C) { 1555 PrintCallingConv(F->getCallingConv(), Out); 1556 Out << " "; 1557 } 1558 1559 FunctionType *FT = F->getFunctionType(); 1560 const AttributeSet &Attrs = F->getAttributes(); 1561 if (Attrs.hasAttributes(AttributeSet::ReturnIndex)) 1562 Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' '; 1563 TypePrinter.print(F->getReturnType(), Out); 1564 Out << ' '; 1565 WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent()); 1566 Out << '('; 1567 Machine.incorporateFunction(F); 1568 1569 // Loop over the arguments, printing them... 1570 1571 unsigned Idx = 1; 1572 if (!F->isDeclaration()) { 1573 // If this isn't a declaration, print the argument names as well. 1574 for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 1575 I != E; ++I) { 1576 // Insert commas as we go... the first arg doesn't get a comma 1577 if (I != F->arg_begin()) Out << ", "; 1578 printArgument(I, Attrs, Idx); 1579 Idx++; 1580 } 1581 } else { 1582 // Otherwise, print the types from the function type. 1583 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 1584 // Insert commas as we go... the first arg doesn't get a comma 1585 if (i) Out << ", "; 1586 1587 // Output type... 1588 TypePrinter.print(FT->getParamType(i), Out); 1589 1590 if (Attrs.hasAttributes(i+1)) 1591 Out << ' ' << Attrs.getAsString(i+1); 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 if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) 1604 Out << ' ' << Attrs.getAsString(AttributeSet::FunctionIndex); 1605 if (F->hasSection()) { 1606 Out << " section \""; 1607 PrintEscapedString(F->getSection(), Out); 1608 Out << '"'; 1609 } 1610 if (F->getAlignment()) 1611 Out << " align " << F->getAlignment(); 1612 if (F->hasGC()) 1613 Out << " gc \"" << F->getGC() << '"'; 1614 if (F->isDeclaration()) { 1615 Out << '\n'; 1616 } else { 1617 Out << " {"; 1618 // Output all of the function's basic blocks. 1619 for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) 1620 printBasicBlock(I); 1621 1622 Out << "}\n"; 1623 } 1624 1625 Machine.purgeFunction(); 1626} 1627 1628/// printArgument - This member is called for every argument that is passed into 1629/// the function. Simply print it out 1630/// 1631void AssemblyWriter::printArgument(const Argument *Arg, 1632 AttributeSet Attrs, unsigned Idx) { 1633 // Output type... 1634 TypePrinter.print(Arg->getType(), Out); 1635 1636 // Output parameter attributes list 1637 if (Attrs.hasAttributes(Idx)) 1638 Out << ' ' << Attrs.getAsString(Idx); 1639 1640 // Output name, if available... 1641 if (Arg->hasName()) { 1642 Out << ' '; 1643 PrintLLVMName(Out, Arg); 1644 } 1645} 1646 1647/// printBasicBlock - This member is called for each basic block in a method. 1648/// 1649void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { 1650 if (BB->hasName()) { // Print out the label if it exists... 1651 Out << "\n"; 1652 PrintLLVMName(Out, BB->getName(), LabelPrefix); 1653 Out << ':'; 1654 } else if (!BB->use_empty()) { // Don't print block # of no uses... 1655 Out << "\n; <label>:"; 1656 int Slot = Machine.getLocalSlot(BB); 1657 if (Slot != -1) 1658 Out << Slot; 1659 else 1660 Out << "<badref>"; 1661 } 1662 1663 if (BB->getParent() == 0) { 1664 Out.PadToColumn(50); 1665 Out << "; Error: Block without parent!"; 1666 } else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block? 1667 // Output predecessors for the block. 1668 Out.PadToColumn(50); 1669 Out << ";"; 1670 const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB); 1671 1672 if (PI == PE) { 1673 Out << " No predecessors!"; 1674 } else { 1675 Out << " preds = "; 1676 writeOperand(*PI, false); 1677 for (++PI; PI != PE; ++PI) { 1678 Out << ", "; 1679 writeOperand(*PI, false); 1680 } 1681 } 1682 } 1683 1684 Out << "\n"; 1685 1686 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out); 1687 1688 // Output all of the instructions in the basic block... 1689 for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 1690 printInstruction(*I); 1691 Out << '\n'; 1692 } 1693 1694 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out); 1695} 1696 1697/// printInfoComment - Print a little comment after the instruction indicating 1698/// which slot it occupies. 1699/// 1700void AssemblyWriter::printInfoComment(const Value &V) { 1701 if (AnnotationWriter) { 1702 AnnotationWriter->printInfoComment(V, Out); 1703 return; 1704 } 1705} 1706 1707// This member is called for each Instruction in a function.. 1708void AssemblyWriter::printInstruction(const Instruction &I) { 1709 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out); 1710 1711 // Print out indentation for an instruction. 1712 Out << " "; 1713 1714 // Print out name if it exists... 1715 if (I.hasName()) { 1716 PrintLLVMName(Out, &I); 1717 Out << " = "; 1718 } else if (!I.getType()->isVoidTy()) { 1719 // Print out the def slot taken. 1720 int SlotNum = Machine.getLocalSlot(&I); 1721 if (SlotNum == -1) 1722 Out << "<badref> = "; 1723 else 1724 Out << '%' << SlotNum << " = "; 1725 } 1726 1727 if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) 1728 Out << "tail "; 1729 1730 // Print out the opcode... 1731 Out << I.getOpcodeName(); 1732 1733 // If this is an atomic load or store, print out the atomic marker. 1734 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) || 1735 (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic())) 1736 Out << " atomic"; 1737 1738 // If this is a volatile operation, print out the volatile marker. 1739 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) || 1740 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) || 1741 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) || 1742 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile())) 1743 Out << " volatile"; 1744 1745 // Print out optimization information. 1746 WriteOptimizationInfo(Out, &I); 1747 1748 // Print out the compare instruction predicates 1749 if (const CmpInst *CI = dyn_cast<CmpInst>(&I)) 1750 Out << ' ' << getPredicateText(CI->getPredicate()); 1751 1752 // Print out the atomicrmw operation 1753 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) 1754 writeAtomicRMWOperation(Out, RMWI->getOperation()); 1755 1756 // Print out the type of the operands... 1757 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0; 1758 1759 // Special case conditional branches to swizzle the condition out to the front 1760 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) { 1761 BranchInst &BI(cast<BranchInst>(I)); 1762 Out << ' '; 1763 writeOperand(BI.getCondition(), true); 1764 Out << ", "; 1765 writeOperand(BI.getSuccessor(0), true); 1766 Out << ", "; 1767 writeOperand(BI.getSuccessor(1), true); 1768 1769 } else if (isa<SwitchInst>(I)) { 1770 SwitchInst& SI(cast<SwitchInst>(I)); 1771 // Special case switch instruction to get formatting nice and correct. 1772 Out << ' '; 1773 writeOperand(SI.getCondition(), true); 1774 Out << ", "; 1775 writeOperand(SI.getDefaultDest(), true); 1776 Out << " ["; 1777 for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); 1778 i != e; ++i) { 1779 Out << "\n "; 1780 writeOperand(i.getCaseValue(), true); 1781 Out << ", "; 1782 writeOperand(i.getCaseSuccessor(), true); 1783 } 1784 Out << "\n ]"; 1785 } else if (isa<IndirectBrInst>(I)) { 1786 // Special case indirectbr instruction to get formatting nice and correct. 1787 Out << ' '; 1788 writeOperand(Operand, true); 1789 Out << ", ["; 1790 1791 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) { 1792 if (i != 1) 1793 Out << ", "; 1794 writeOperand(I.getOperand(i), true); 1795 } 1796 Out << ']'; 1797 } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) { 1798 Out << ' '; 1799 TypePrinter.print(I.getType(), Out); 1800 Out << ' '; 1801 1802 for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) { 1803 if (op) Out << ", "; 1804 Out << "[ "; 1805 writeOperand(PN->getIncomingValue(op), false); Out << ", "; 1806 writeOperand(PN->getIncomingBlock(op), false); Out << " ]"; 1807 } 1808 } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) { 1809 Out << ' '; 1810 writeOperand(I.getOperand(0), true); 1811 for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i) 1812 Out << ", " << *i; 1813 } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) { 1814 Out << ' '; 1815 writeOperand(I.getOperand(0), true); Out << ", "; 1816 writeOperand(I.getOperand(1), true); 1817 for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i) 1818 Out << ", " << *i; 1819 } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) { 1820 Out << ' '; 1821 TypePrinter.print(I.getType(), Out); 1822 Out << " personality "; 1823 writeOperand(I.getOperand(0), true); Out << '\n'; 1824 1825 if (LPI->isCleanup()) 1826 Out << " cleanup"; 1827 1828 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) { 1829 if (i != 0 || LPI->isCleanup()) Out << "\n"; 1830 if (LPI->isCatch(i)) 1831 Out << " catch "; 1832 else 1833 Out << " filter "; 1834 1835 writeOperand(LPI->getClause(i), true); 1836 } 1837 } else if (isa<ReturnInst>(I) && !Operand) { 1838 Out << " void"; 1839 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { 1840 // Print the calling convention being used. 1841 if (CI->getCallingConv() != CallingConv::C) { 1842 Out << " "; 1843 PrintCallingConv(CI->getCallingConv(), Out); 1844 } 1845 1846 Operand = CI->getCalledValue(); 1847 PointerType *PTy = cast<PointerType>(Operand->getType()); 1848 FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1849 Type *RetTy = FTy->getReturnType(); 1850 const AttributeSet &PAL = CI->getAttributes(); 1851 1852 if (PAL.hasAttributes(AttributeSet::ReturnIndex)) 1853 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); 1854 1855 // If possible, print out the short form of the call instruction. We can 1856 // only do this if the first argument is a pointer to a nonvararg function, 1857 // and if the return type is not a pointer to a function. 1858 // 1859 Out << ' '; 1860 if (!FTy->isVarArg() && 1861 (!RetTy->isPointerTy() || 1862 !cast<PointerType>(RetTy)->getElementType()->isFunctionTy())) { 1863 TypePrinter.print(RetTy, Out); 1864 Out << ' '; 1865 writeOperand(Operand, false); 1866 } else { 1867 writeOperand(Operand, true); 1868 } 1869 Out << '('; 1870 for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) { 1871 if (op > 0) 1872 Out << ", "; 1873 writeParamOperand(CI->getArgOperand(op), PAL, op + 1); 1874 } 1875 Out << ')'; 1876 if (PAL.hasAttributes(AttributeSet::FunctionIndex)) 1877 Out << ' ' << PAL.getAsString(AttributeSet::FunctionIndex); 1878 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { 1879 Operand = II->getCalledValue(); 1880 PointerType *PTy = cast<PointerType>(Operand->getType()); 1881 FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 1882 Type *RetTy = FTy->getReturnType(); 1883 const AttributeSet &PAL = II->getAttributes(); 1884 1885 // Print the calling convention being used. 1886 if (II->getCallingConv() != CallingConv::C) { 1887 Out << " "; 1888 PrintCallingConv(II->getCallingConv(), Out); 1889 } 1890 1891 if (PAL.hasAttributes(AttributeSet::ReturnIndex)) 1892 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex); 1893 1894 // If possible, print out the short form of the invoke instruction. We can 1895 // only do this if the first argument is a pointer to a nonvararg function, 1896 // and if the return type is not a pointer to a function. 1897 // 1898 Out << ' '; 1899 if (!FTy->isVarArg() && 1900 (!RetTy->isPointerTy() || 1901 !cast<PointerType>(RetTy)->getElementType()->isFunctionTy())) { 1902 TypePrinter.print(RetTy, Out); 1903 Out << ' '; 1904 writeOperand(Operand, false); 1905 } else { 1906 writeOperand(Operand, true); 1907 } 1908 Out << '('; 1909 for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) { 1910 if (op) 1911 Out << ", "; 1912 writeParamOperand(II->getArgOperand(op), PAL, op + 1); 1913 } 1914 1915 Out << ')'; 1916 if (PAL.hasAttributes(AttributeSet::FunctionIndex)) 1917 Out << ' ' << PAL.getAsString(AttributeSet::FunctionIndex); 1918 1919 Out << "\n to "; 1920 writeOperand(II->getNormalDest(), true); 1921 Out << " unwind "; 1922 writeOperand(II->getUnwindDest(), true); 1923 1924 } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) { 1925 Out << ' '; 1926 TypePrinter.print(AI->getAllocatedType(), Out); 1927 if (!AI->getArraySize() || AI->isArrayAllocation()) { 1928 Out << ", "; 1929 writeOperand(AI->getArraySize(), true); 1930 } 1931 if (AI->getAlignment()) { 1932 Out << ", align " << AI->getAlignment(); 1933 } 1934 } else if (isa<CastInst>(I)) { 1935 if (Operand) { 1936 Out << ' '; 1937 writeOperand(Operand, true); // Work with broken code 1938 } 1939 Out << " to "; 1940 TypePrinter.print(I.getType(), Out); 1941 } else if (isa<VAArgInst>(I)) { 1942 if (Operand) { 1943 Out << ' '; 1944 writeOperand(Operand, true); // Work with broken code 1945 } 1946 Out << ", "; 1947 TypePrinter.print(I.getType(), Out); 1948 } else if (Operand) { // Print the normal way. 1949 1950 // PrintAllTypes - Instructions who have operands of all the same type 1951 // omit the type from all but the first operand. If the instruction has 1952 // different type operands (for example br), then they are all printed. 1953 bool PrintAllTypes = false; 1954 Type *TheType = Operand->getType(); 1955 1956 // Select, Store and ShuffleVector always print all types. 1957 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I) 1958 || isa<ReturnInst>(I)) { 1959 PrintAllTypes = true; 1960 } else { 1961 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) { 1962 Operand = I.getOperand(i); 1963 // note that Operand shouldn't be null, but the test helps make dump() 1964 // more tolerant of malformed IR 1965 if (Operand && Operand->getType() != TheType) { 1966 PrintAllTypes = true; // We have differing types! Print them all! 1967 break; 1968 } 1969 } 1970 } 1971 1972 if (!PrintAllTypes) { 1973 Out << ' '; 1974 TypePrinter.print(TheType, Out); 1975 } 1976 1977 Out << ' '; 1978 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { 1979 if (i) Out << ", "; 1980 writeOperand(I.getOperand(i), PrintAllTypes); 1981 } 1982 } 1983 1984 // Print atomic ordering/alignment for memory operations 1985 if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) { 1986 if (LI->isAtomic()) 1987 writeAtomic(LI->getOrdering(), LI->getSynchScope()); 1988 if (LI->getAlignment()) 1989 Out << ", align " << LI->getAlignment(); 1990 } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) { 1991 if (SI->isAtomic()) 1992 writeAtomic(SI->getOrdering(), SI->getSynchScope()); 1993 if (SI->getAlignment()) 1994 Out << ", align " << SI->getAlignment(); 1995 } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) { 1996 writeAtomic(CXI->getOrdering(), CXI->getSynchScope()); 1997 } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) { 1998 writeAtomic(RMWI->getOrdering(), RMWI->getSynchScope()); 1999 } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) { 2000 writeAtomic(FI->getOrdering(), FI->getSynchScope()); 2001 } 2002 2003 // Print Metadata info. 2004 SmallVector<std::pair<unsigned, MDNode*>, 4> InstMD; 2005 I.getAllMetadata(InstMD); 2006 if (!InstMD.empty()) { 2007 SmallVector<StringRef, 8> MDNames; 2008 I.getType()->getContext().getMDKindNames(MDNames); 2009 for (unsigned i = 0, e = InstMD.size(); i != e; ++i) { 2010 unsigned Kind = InstMD[i].first; 2011 if (Kind < MDNames.size()) { 2012 Out << ", !" << MDNames[Kind]; 2013 } else { 2014 Out << ", !<unknown kind #" << Kind << ">"; 2015 } 2016 Out << ' '; 2017 WriteAsOperandInternal(Out, InstMD[i].second, &TypePrinter, &Machine, 2018 TheModule); 2019 } 2020 } 2021 printInfoComment(I); 2022} 2023 2024static void WriteMDNodeComment(const MDNode *Node, 2025 formatted_raw_ostream &Out) { 2026 if (Node->getNumOperands() < 1) 2027 return; 2028 2029 Value *Op = Node->getOperand(0); 2030 if (!Op || !isa<ConstantInt>(Op) || cast<ConstantInt>(Op)->getBitWidth() < 32) 2031 return; 2032 2033 DIDescriptor Desc(Node); 2034 if (Desc.getVersion() < LLVMDebugVersion11) 2035 return; 2036 2037 unsigned Tag = Desc.getTag(); 2038 Out.PadToColumn(50); 2039 if (dwarf::TagString(Tag)) { 2040 Out << "; "; 2041 Desc.print(Out); 2042 } else if (Tag == dwarf::DW_TAG_user_base) { 2043 Out << "; [ DW_TAG_user_base ]"; 2044 } 2045} 2046 2047void AssemblyWriter::writeAllMDNodes() { 2048 SmallVector<const MDNode *, 16> Nodes; 2049 Nodes.resize(Machine.mdn_size()); 2050 for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end(); 2051 I != E; ++I) 2052 Nodes[I->second] = cast<MDNode>(I->first); 2053 2054 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) { 2055 Out << '!' << i << " = metadata "; 2056 printMDNodeBody(Nodes[i]); 2057 } 2058} 2059 2060void AssemblyWriter::printMDNodeBody(const MDNode *Node) { 2061 WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule); 2062 WriteMDNodeComment(Node, Out); 2063 Out << "\n"; 2064} 2065 2066//===----------------------------------------------------------------------===// 2067// External Interface declarations 2068//===----------------------------------------------------------------------===// 2069 2070void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2071 SlotTracker SlotTable(this); 2072 formatted_raw_ostream OS(ROS); 2073 AssemblyWriter W(OS, SlotTable, this, AAW); 2074 W.printModule(this); 2075} 2076 2077void NamedMDNode::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2078 SlotTracker SlotTable(getParent()); 2079 formatted_raw_ostream OS(ROS); 2080 AssemblyWriter W(OS, SlotTable, getParent(), AAW); 2081 W.printNamedMDNode(this); 2082} 2083 2084void Type::print(raw_ostream &OS) const { 2085 if (this == 0) { 2086 OS << "<null Type>"; 2087 return; 2088 } 2089 TypePrinting TP; 2090 TP.print(const_cast<Type*>(this), OS); 2091 2092 // If the type is a named struct type, print the body as well. 2093 if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this))) 2094 if (!STy->isLiteral()) { 2095 OS << " = type "; 2096 TP.printStructBody(STy, OS); 2097 } 2098} 2099 2100void Value::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const { 2101 if (this == 0) { 2102 ROS << "printing a <null> value\n"; 2103 return; 2104 } 2105 formatted_raw_ostream OS(ROS); 2106 if (const Instruction *I = dyn_cast<Instruction>(this)) { 2107 const Function *F = I->getParent() ? I->getParent()->getParent() : 0; 2108 SlotTracker SlotTable(F); 2109 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), AAW); 2110 W.printInstruction(*I); 2111 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) { 2112 SlotTracker SlotTable(BB->getParent()); 2113 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), AAW); 2114 W.printBasicBlock(BB); 2115 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) { 2116 SlotTracker SlotTable(GV->getParent()); 2117 AssemblyWriter W(OS, SlotTable, GV->getParent(), AAW); 2118 if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV)) 2119 W.printGlobal(V); 2120 else if (const Function *F = dyn_cast<Function>(GV)) 2121 W.printFunction(F); 2122 else 2123 W.printAlias(cast<GlobalAlias>(GV)); 2124 } else if (const MDNode *N = dyn_cast<MDNode>(this)) { 2125 const Function *F = N->getFunction(); 2126 SlotTracker SlotTable(F); 2127 AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW); 2128 W.printMDNodeBody(N); 2129 } else if (const Constant *C = dyn_cast<Constant>(this)) { 2130 TypePrinting TypePrinter; 2131 TypePrinter.print(C->getType(), OS); 2132 OS << ' '; 2133 WriteConstantInternal(OS, C, TypePrinter, 0, 0); 2134 } else if (isa<InlineAsm>(this) || isa<MDString>(this) || 2135 isa<Argument>(this)) { 2136 WriteAsOperand(OS, this, true, 0); 2137 } else { 2138 // Otherwise we don't know what it is. Call the virtual function to 2139 // allow a subclass to print itself. 2140 printCustom(OS); 2141 } 2142} 2143 2144// Value::printCustom - subclasses should override this to implement printing. 2145void Value::printCustom(raw_ostream &OS) const { 2146 llvm_unreachable("Unknown value to print out!"); 2147} 2148 2149// Value::dump - allow easy printing of Values from the debugger. 2150void Value::dump() const { print(dbgs()); dbgs() << '\n'; } 2151 2152// Type::dump - allow easy printing of Types from the debugger. 2153void Type::dump() const { print(dbgs()); } 2154 2155// Module::dump() - Allow printing of Modules from the debugger. 2156void Module::dump() const { print(dbgs(), 0); } 2157 2158// NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger. 2159void NamedMDNode::dump() const { print(dbgs(), 0); } 2160