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