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