2 //===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 // This library implements the functionality defined in llvm/IR/Writer.h
13 // Note that these routines must be extremely tolerant of various errors in the
14 // LLVM code, because it can be used for debugging transformations.
16 //===----------------------------------------------------------------------===//
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SetVector.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/IR/AssemblyAnnotationWriter.h"
24 #include "llvm/IR/CFG.h"
25 #include "llvm/IR/CallingConv.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/DebugInfo.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/IRPrintingPasses.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/ModuleSlotTracker.h"
35 #include "llvm/IR/Operator.h"
36 #include "llvm/IR/Statepoint.h"
37 #include "llvm/IR/TypeFinder.h"
38 #include "llvm/IR/UseListOrder.h"
39 #include "llvm/IR/ValueSymbolTable.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/Dwarf.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/Format.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/MathExtras.h"
46 #include "llvm/Support/raw_ostream.h"
51 // Make virtual table appear in this compilation unit.
52 AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
54 //===----------------------------------------------------------------------===//
56 //===----------------------------------------------------------------------===//
60 DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
62 unsigned size() const { return IDs.size(); }
63 std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
64 std::pair<unsigned, bool> lookup(const Value *V) const {
67 void index(const Value *V) {
68 // Explicitly sequence get-size and insert-value operations to avoid UB.
69 unsigned ID = IDs.size() + 1;
75 static void orderValue(const Value *V, OrderMap &OM) {
76 if (OM.lookup(V).first)
79 if (const Constant *C = dyn_cast<Constant>(V))
80 if (C->getNumOperands() && !isa<GlobalValue>(C))
81 for (const Value *Op : C->operands())
82 if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
85 // Note: we cannot cache this lookup above, since inserting into the map
86 // changes the map's size, and thus affects the other IDs.
90 static OrderMap orderModule(const Module *M) {
91 // This needs to match the order used by ValueEnumerator::ValueEnumerator()
92 // and ValueEnumerator::incorporateFunction().
95 for (const GlobalVariable &G : M->globals()) {
96 if (G.hasInitializer())
97 if (!isa<GlobalValue>(G.getInitializer()))
98 orderValue(G.getInitializer(), OM);
101 for (const GlobalAlias &A : M->aliases()) {
102 if (!isa<GlobalValue>(A.getAliasee()))
103 orderValue(A.getAliasee(), OM);
106 for (const GlobalIFunc &I : M->ifuncs()) {
107 if (!isa<GlobalValue>(I.getResolver()))
108 orderValue(I.getResolver(), OM);
111 for (const Function &F : *M) {
112 for (const Use &U : F.operands())
113 if (!isa<GlobalValue>(U.get()))
114 orderValue(U.get(), OM);
118 if (F.isDeclaration())
121 for (const Argument &A : F.args())
123 for (const BasicBlock &BB : F) {
125 for (const Instruction &I : BB) {
126 for (const Value *Op : I.operands())
127 if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
137 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
138 unsigned ID, const OrderMap &OM,
139 UseListOrderStack &Stack) {
140 // Predict use-list order for this one.
141 typedef std::pair<const Use *, unsigned> Entry;
142 SmallVector<Entry, 64> List;
143 for (const Use &U : V->uses())
144 // Check if this user will be serialized.
145 if (OM.lookup(U.getUser()).first)
146 List.push_back(std::make_pair(&U, List.size()));
149 // We may have lost some users.
153 !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
154 if (auto *BA = dyn_cast<BlockAddress>(V))
155 ID = OM.lookup(BA->getBasicBlock()).first;
156 std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) {
157 const Use *LU = L.first;
158 const Use *RU = R.first;
162 auto LID = OM.lookup(LU->getUser()).first;
163 auto RID = OM.lookup(RU->getUser()).first;
165 // If ID is 4, then expect: 7 6 5 1 2 3.
179 // LID and RID are equal, so we have different operands of the same user.
180 // Assume operands are added in order for all instructions.
183 return LU->getOperandNo() < RU->getOperandNo();
184 return LU->getOperandNo() > RU->getOperandNo();
188 List.begin(), List.end(),
189 [](const Entry &L, const Entry &R) { return L.second < R.second; }))
190 // Order is already correct.
193 // Store the shuffle.
194 Stack.emplace_back(V, F, List.size());
195 assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
196 for (size_t I = 0, E = List.size(); I != E; ++I)
197 Stack.back().Shuffle[I] = List[I].second;
200 static void predictValueUseListOrder(const Value *V, const Function *F,
201 OrderMap &OM, UseListOrderStack &Stack) {
202 auto &IDPair = OM[V];
203 assert(IDPair.first && "Unmapped value");
205 // Already predicted.
208 // Do the actual prediction.
209 IDPair.second = true;
210 if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())
211 predictValueUseListOrderImpl(V, F, IDPair.first, OM, Stack);
213 // Recursive descent into constants.
214 if (const Constant *C = dyn_cast<Constant>(V))
215 if (C->getNumOperands()) // Visit GlobalValues.
216 for (const Value *Op : C->operands())
217 if (isa<Constant>(Op)) // Visit GlobalValues.
218 predictValueUseListOrder(Op, F, OM, Stack);
221 static UseListOrderStack predictUseListOrder(const Module *M) {
222 OrderMap OM = orderModule(M);
224 // Use-list orders need to be serialized after all the users have been added
225 // to a value, or else the shuffles will be incomplete. Store them per
226 // function in a stack.
228 // Aside from function order, the order of values doesn't matter much here.
229 UseListOrderStack Stack;
231 // We want to visit the functions backward now so we can list function-local
232 // constants in the last Function they're used in. Module-level constants
233 // have already been visited above.
234 for (const Function &F : make_range(M->rbegin(), M->rend())) {
235 if (F.isDeclaration())
237 for (const BasicBlock &BB : F)
238 predictValueUseListOrder(&BB, &F, OM, Stack);
239 for (const Argument &A : F.args())
240 predictValueUseListOrder(&A, &F, OM, Stack);
241 for (const BasicBlock &BB : F)
242 for (const Instruction &I : BB)
243 for (const Value *Op : I.operands())
244 if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
245 predictValueUseListOrder(Op, &F, OM, Stack);
246 for (const BasicBlock &BB : F)
247 for (const Instruction &I : BB)
248 predictValueUseListOrder(&I, &F, OM, Stack);
251 // Visit globals last.
252 for (const GlobalVariable &G : M->globals())
253 predictValueUseListOrder(&G, nullptr, OM, Stack);
254 for (const Function &F : *M)
255 predictValueUseListOrder(&F, nullptr, OM, Stack);
256 for (const GlobalAlias &A : M->aliases())
257 predictValueUseListOrder(&A, nullptr, OM, Stack);
258 for (const GlobalIFunc &I : M->ifuncs())
259 predictValueUseListOrder(&I, nullptr, OM, Stack);
260 for (const GlobalVariable &G : M->globals())
261 if (G.hasInitializer())
262 predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
263 for (const GlobalAlias &A : M->aliases())
264 predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
265 for (const GlobalIFunc &I : M->ifuncs())
266 predictValueUseListOrder(I.getResolver(), nullptr, OM, Stack);
267 for (const Function &F : *M)
268 for (const Use &U : F.operands())
269 predictValueUseListOrder(U.get(), nullptr, OM, Stack);
274 static const Module *getModuleFromVal(const Value *V) {
275 if (const Argument *MA = dyn_cast<Argument>(V))
276 return MA->getParent() ? MA->getParent()->getParent() : nullptr;
278 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
279 return BB->getParent() ? BB->getParent()->getParent() : nullptr;
281 if (const Instruction *I = dyn_cast<Instruction>(V)) {
282 const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
283 return M ? M->getParent() : nullptr;
286 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
287 return GV->getParent();
289 if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
290 for (const User *U : MAV->users())
291 if (isa<Instruction>(U))
292 if (const Module *M = getModuleFromVal(U))
300 static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
302 default: Out << "cc" << cc; break;
303 case CallingConv::Fast: Out << "fastcc"; break;
304 case CallingConv::Cold: Out << "coldcc"; break;
305 case CallingConv::WebKit_JS: Out << "webkit_jscc"; break;
306 case CallingConv::AnyReg: Out << "anyregcc"; break;
307 case CallingConv::PreserveMost: Out << "preserve_mostcc"; break;
308 case CallingConv::PreserveAll: Out << "preserve_allcc"; break;
309 case CallingConv::CXX_FAST_TLS: Out << "cxx_fast_tlscc"; break;
310 case CallingConv::GHC: Out << "ghccc"; break;
311 case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break;
312 case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break;
313 case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break;
314 case CallingConv::X86_RegCall: Out << "x86_regcallcc"; break;
315 case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
316 case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break;
317 case CallingConv::ARM_APCS: Out << "arm_apcscc"; break;
318 case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break;
319 case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
320 case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break;
321 case CallingConv::AVR_INTR: Out << "avr_intrcc "; break;
322 case CallingConv::AVR_SIGNAL: Out << "avr_signalcc "; break;
323 case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break;
324 case CallingConv::PTX_Device: Out << "ptx_device"; break;
325 case CallingConv::X86_64_SysV: Out << "x86_64_sysvcc"; break;
326 case CallingConv::X86_64_Win64: Out << "x86_64_win64cc"; break;
327 case CallingConv::SPIR_FUNC: Out << "spir_func"; break;
328 case CallingConv::SPIR_KERNEL: Out << "spir_kernel"; break;
329 case CallingConv::Swift: Out << "swiftcc"; break;
330 case CallingConv::X86_INTR: Out << "x86_intrcc"; break;
331 case CallingConv::HHVM: Out << "hhvmcc"; break;
332 case CallingConv::HHVM_C: Out << "hhvm_ccc"; break;
333 case CallingConv::AMDGPU_VS: Out << "amdgpu_vs"; break;
334 case CallingConv::AMDGPU_GS: Out << "amdgpu_gs"; break;
335 case CallingConv::AMDGPU_PS: Out << "amdgpu_ps"; break;
336 case CallingConv::AMDGPU_CS: Out << "amdgpu_cs"; break;
337 case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
341 void llvm::PrintEscapedString(StringRef Name, raw_ostream &Out) {
342 for (unsigned i = 0, e = Name.size(); i != e; ++i) {
343 unsigned char C = Name[i];
344 if (isprint(C) && C != '\\' && C != '"')
347 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
359 void llvm::printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name) {
360 assert(!Name.empty() && "Cannot get empty name!");
362 // Scan the name to see if it needs quotes first.
363 bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
365 for (unsigned i = 0, e = Name.size(); i != e; ++i) {
366 // By making this unsigned, the value passed in to isalnum will always be
367 // in the range 0-255. This is important when building with MSVC because
368 // its implementation will assert. This situation can arise when dealing
369 // with UTF-8 multibyte characters.
370 unsigned char C = Name[i];
371 if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
379 // If we didn't need any quotes, just write out the name in one blast.
385 // Okay, we need quotes. Output the quotes and escape any scary characters as
388 PrintEscapedString(Name, OS);
392 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
393 /// (if the string only contains simple characters) or is surrounded with ""'s
394 /// (if it has special chars in it). Print it out.
395 static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
411 printLLVMNameWithoutPrefix(OS, Name);
414 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
415 /// (if the string only contains simple characters) or is surrounded with ""'s
416 /// (if it has special chars in it). Print it out.
417 static void PrintLLVMName(raw_ostream &OS, const Value *V) {
418 PrintLLVMName(OS, V->getName(),
419 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
425 TypePrinting(const TypePrinting &) = delete;
426 void operator=(const TypePrinting&) = delete;
429 /// NamedTypes - The named types that are used by the current module.
430 TypeFinder NamedTypes;
432 /// NumberedTypes - The numbered types, along with their value.
433 DenseMap<StructType*, unsigned> NumberedTypes;
435 TypePrinting() = default;
437 void incorporateTypes(const Module &M);
439 void print(Type *Ty, raw_ostream &OS);
441 void printStructBody(StructType *Ty, raw_ostream &OS);
445 void TypePrinting::incorporateTypes(const Module &M) {
446 NamedTypes.run(M, false);
448 // The list of struct types we got back includes all the struct types, split
449 // the unnamed ones out to a numbering and remove the anonymous structs.
450 unsigned NextNumber = 0;
452 std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
453 for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
454 StructType *STy = *I;
456 // Ignore anonymous types.
457 if (STy->isLiteral())
460 if (STy->getName().empty())
461 NumberedTypes[STy] = NextNumber++;
466 NamedTypes.erase(NextToUse, NamedTypes.end());
470 /// CalcTypeName - Write the specified type to the specified raw_ostream, making
471 /// use of type names or up references to shorten the type name where possible.
472 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
473 switch (Ty->getTypeID()) {
474 case Type::VoidTyID: OS << "void"; return;
475 case Type::HalfTyID: OS << "half"; return;
476 case Type::FloatTyID: OS << "float"; return;
477 case Type::DoubleTyID: OS << "double"; return;
478 case Type::X86_FP80TyID: OS << "x86_fp80"; return;
479 case Type::FP128TyID: OS << "fp128"; return;
480 case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
481 case Type::LabelTyID: OS << "label"; return;
482 case Type::MetadataTyID: OS << "metadata"; return;
483 case Type::X86_MMXTyID: OS << "x86_mmx"; return;
484 case Type::TokenTyID: OS << "token"; return;
485 case Type::IntegerTyID:
486 OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
489 case Type::FunctionTyID: {
490 FunctionType *FTy = cast<FunctionType>(Ty);
491 print(FTy->getReturnType(), OS);
493 for (FunctionType::param_iterator I = FTy->param_begin(),
494 E = FTy->param_end(); I != E; ++I) {
495 if (I != FTy->param_begin())
499 if (FTy->isVarArg()) {
500 if (FTy->getNumParams()) OS << ", ";
506 case Type::StructTyID: {
507 StructType *STy = cast<StructType>(Ty);
509 if (STy->isLiteral())
510 return printStructBody(STy, OS);
512 if (!STy->getName().empty())
513 return PrintLLVMName(OS, STy->getName(), LocalPrefix);
515 DenseMap<StructType*, unsigned>::iterator I = NumberedTypes.find(STy);
516 if (I != NumberedTypes.end())
517 OS << '%' << I->second;
518 else // Not enumerated, print the hex address.
519 OS << "%\"type " << STy << '\"';
522 case Type::PointerTyID: {
523 PointerType *PTy = cast<PointerType>(Ty);
524 print(PTy->getElementType(), OS);
525 if (unsigned AddressSpace = PTy->getAddressSpace())
526 OS << " addrspace(" << AddressSpace << ')';
530 case Type::ArrayTyID: {
531 ArrayType *ATy = cast<ArrayType>(Ty);
532 OS << '[' << ATy->getNumElements() << " x ";
533 print(ATy->getElementType(), OS);
537 case Type::VectorTyID: {
538 VectorType *PTy = cast<VectorType>(Ty);
539 OS << "<" << PTy->getNumElements() << " x ";
540 print(PTy->getElementType(), OS);
545 llvm_unreachable("Invalid TypeID");
548 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
549 if (STy->isOpaque()) {
557 if (STy->getNumElements() == 0) {
560 StructType::element_iterator I = STy->element_begin();
563 for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
575 //===----------------------------------------------------------------------===//
576 // SlotTracker Class: Enumerate slot numbers for unnamed values
577 //===----------------------------------------------------------------------===//
578 /// This class provides computation of slot numbers for LLVM Assembly writing.
582 /// ValueMap - A mapping of Values to slot numbers.
583 typedef DenseMap<const Value*, unsigned> ValueMap;
586 /// TheModule - The module for which we are holding slot numbers.
587 const Module* TheModule;
589 /// TheFunction - The function for which we are holding slot numbers.
590 const Function* TheFunction;
591 bool FunctionProcessed;
592 bool ShouldInitializeAllMetadata;
594 /// mMap - The slot map for the module level data.
598 /// fMap - The slot map for the function level data.
602 /// mdnMap - Map for MDNodes.
603 DenseMap<const MDNode*, unsigned> mdnMap;
606 /// asMap - The slot map for attribute sets.
607 DenseMap<AttributeSet, unsigned> asMap;
610 /// Construct from a module.
612 /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
613 /// functions, giving correct numbering for metadata referenced only from
614 /// within a function (even if no functions have been initialized).
615 explicit SlotTracker(const Module *M,
616 bool ShouldInitializeAllMetadata = false);
617 /// Construct from a function, starting out in incorp state.
619 /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
620 /// functions, giving correct numbering for metadata referenced only from
621 /// within a function (even if no functions have been initialized).
622 explicit SlotTracker(const Function *F,
623 bool ShouldInitializeAllMetadata = false);
625 /// Return the slot number of the specified value in it's type
626 /// plane. If something is not in the SlotTracker, return -1.
627 int getLocalSlot(const Value *V);
628 int getGlobalSlot(const GlobalValue *V);
629 int getMetadataSlot(const MDNode *N);
630 int getAttributeGroupSlot(AttributeSet AS);
632 /// If you'd like to deal with a function instead of just a module, use
633 /// this method to get its data into the SlotTracker.
634 void incorporateFunction(const Function *F) {
636 FunctionProcessed = false;
639 const Function *getFunction() const { return TheFunction; }
641 /// After calling incorporateFunction, use this method to remove the
642 /// most recently incorporated function from the SlotTracker. This
643 /// will reset the state of the machine back to just the module contents.
644 void purgeFunction();
646 /// MDNode map iterators.
647 typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator;
648 mdn_iterator mdn_begin() { return mdnMap.begin(); }
649 mdn_iterator mdn_end() { return mdnMap.end(); }
650 unsigned mdn_size() const { return mdnMap.size(); }
651 bool mdn_empty() const { return mdnMap.empty(); }
653 /// AttributeSet map iterators.
654 typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator;
655 as_iterator as_begin() { return asMap.begin(); }
656 as_iterator as_end() { return asMap.end(); }
657 unsigned as_size() const { return asMap.size(); }
658 bool as_empty() const { return asMap.empty(); }
660 /// This function does the actual initialization.
661 inline void initialize();
663 // Implementation Details
665 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
666 void CreateModuleSlot(const GlobalValue *V);
668 /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
669 void CreateMetadataSlot(const MDNode *N);
671 /// CreateFunctionSlot - Insert the specified Value* into the slot table.
672 void CreateFunctionSlot(const Value *V);
674 /// \brief Insert the specified AttributeSet into the slot table.
675 void CreateAttributeSetSlot(AttributeSet AS);
677 /// Add all of the module level global variables (and their initializers)
678 /// and function declarations, but not the contents of those functions.
679 void processModule();
681 /// Add all of the functions arguments, basic blocks, and instructions.
682 void processFunction();
684 /// Add the metadata directly attached to a GlobalObject.
685 void processGlobalObjectMetadata(const GlobalObject &GO);
687 /// Add all of the metadata from a function.
688 void processFunctionMetadata(const Function &F);
690 /// Add all of the metadata from an instruction.
691 void processInstructionMetadata(const Instruction &I);
693 SlotTracker(const SlotTracker &) = delete;
694 void operator=(const SlotTracker &) = delete;
698 ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
700 : M(M), F(F), Machine(&Machine) {}
702 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
703 bool ShouldInitializeAllMetadata)
704 : ShouldCreateStorage(M),
705 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
707 ModuleSlotTracker::~ModuleSlotTracker() {}
709 SlotTracker *ModuleSlotTracker::getMachine() {
710 if (!ShouldCreateStorage)
713 ShouldCreateStorage = false;
715 llvm::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
716 Machine = MachineStorage.get();
720 void ModuleSlotTracker::incorporateFunction(const Function &F) {
721 // Using getMachine() may lazily create the slot tracker.
725 // Nothing to do if this is the right function already.
729 Machine->purgeFunction();
730 Machine->incorporateFunction(&F);
734 int ModuleSlotTracker::getLocalSlot(const Value *V) {
735 assert(F && "No function incorporated");
736 return Machine->getLocalSlot(V);
739 static SlotTracker *createSlotTracker(const Value *V) {
740 if (const Argument *FA = dyn_cast<Argument>(V))
741 return new SlotTracker(FA->getParent());
743 if (const Instruction *I = dyn_cast<Instruction>(V))
745 return new SlotTracker(I->getParent()->getParent());
747 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
748 return new SlotTracker(BB->getParent());
750 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
751 return new SlotTracker(GV->getParent());
753 if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
754 return new SlotTracker(GA->getParent());
756 if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
757 return new SlotTracker(GIF->getParent());
759 if (const Function *Func = dyn_cast<Function>(V))
760 return new SlotTracker(Func);
766 #define ST_DEBUG(X) dbgs() << X
771 // Module level constructor. Causes the contents of the Module (sans functions)
772 // to be added to the slot table.
773 SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
774 : TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
775 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
776 fNext(0), mdnNext(0), asNext(0) {}
778 // Function level constructor. Causes the contents of the Module and the one
779 // function provided to be added to the slot table.
780 SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
781 : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
782 FunctionProcessed(false),
783 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
784 fNext(0), mdnNext(0), asNext(0) {}
786 inline void SlotTracker::initialize() {
789 TheModule = nullptr; ///< Prevent re-processing next time we're called.
792 if (TheFunction && !FunctionProcessed)
796 // Iterate through all the global variables, functions, and global
797 // variable initializers and create slots for them.
798 void SlotTracker::processModule() {
799 ST_DEBUG("begin processModule!\n");
801 // Add all of the unnamed global variables to the value table.
802 for (const GlobalVariable &Var : TheModule->globals()) {
804 CreateModuleSlot(&Var);
805 processGlobalObjectMetadata(Var);
808 for (const GlobalAlias &A : TheModule->aliases()) {
810 CreateModuleSlot(&A);
813 for (const GlobalIFunc &I : TheModule->ifuncs()) {
815 CreateModuleSlot(&I);
818 // Add metadata used by named metadata.
819 for (const NamedMDNode &NMD : TheModule->named_metadata()) {
820 for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
821 CreateMetadataSlot(NMD.getOperand(i));
824 for (const Function &F : *TheModule) {
826 // Add all the unnamed functions to the table.
827 CreateModuleSlot(&F);
829 if (ShouldInitializeAllMetadata)
830 processFunctionMetadata(F);
832 // Add all the function attributes to the table.
833 // FIXME: Add attributes of other objects?
834 AttributeSet FnAttrs = F.getAttributes().getFnAttributes();
835 if (FnAttrs.hasAttributes(AttributeSet::FunctionIndex))
836 CreateAttributeSetSlot(FnAttrs);
839 ST_DEBUG("end processModule!\n");
842 // Process the arguments, basic blocks, and instructions of a function.
843 void SlotTracker::processFunction() {
844 ST_DEBUG("begin processFunction!\n");
847 // Process function metadata if it wasn't hit at the module-level.
848 if (!ShouldInitializeAllMetadata)
849 processFunctionMetadata(*TheFunction);
851 // Add all the function arguments with no names.
852 for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
853 AE = TheFunction->arg_end(); AI != AE; ++AI)
855 CreateFunctionSlot(&*AI);
857 ST_DEBUG("Inserting Instructions:\n");
859 // Add all of the basic blocks and instructions with no names.
860 for (auto &BB : *TheFunction) {
862 CreateFunctionSlot(&BB);
865 if (!I.getType()->isVoidTy() && !I.hasName())
866 CreateFunctionSlot(&I);
868 // We allow direct calls to any llvm.foo function here, because the
869 // target may not be linked into the optimizer.
870 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
871 // Add all the call attributes to the table.
872 AttributeSet Attrs = CI->getAttributes().getFnAttributes();
873 if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
874 CreateAttributeSetSlot(Attrs);
875 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
876 // Add all the call attributes to the table.
877 AttributeSet Attrs = II->getAttributes().getFnAttributes();
878 if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
879 CreateAttributeSetSlot(Attrs);
884 FunctionProcessed = true;
886 ST_DEBUG("end processFunction!\n");
889 void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
890 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
891 GO.getAllMetadata(MDs);
893 CreateMetadataSlot(MD.second);
896 void SlotTracker::processFunctionMetadata(const Function &F) {
897 processGlobalObjectMetadata(F);
900 processInstructionMetadata(I);
904 void SlotTracker::processInstructionMetadata(const Instruction &I) {
905 // Process metadata used directly by intrinsics.
906 if (const CallInst *CI = dyn_cast<CallInst>(&I))
907 if (Function *F = CI->getCalledFunction())
908 if (F->isIntrinsic())
909 for (auto &Op : I.operands())
910 if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
911 if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
912 CreateMetadataSlot(N);
914 // Process metadata attached to this instruction.
915 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
916 I.getAllMetadata(MDs);
918 CreateMetadataSlot(MD.second);
921 /// Clean up after incorporating a function. This is the only way to get out of
922 /// the function incorporation state that affects get*Slot/Create*Slot. Function
923 /// incorporation state is indicated by TheFunction != 0.
924 void SlotTracker::purgeFunction() {
925 ST_DEBUG("begin purgeFunction!\n");
926 fMap.clear(); // Simply discard the function level map
927 TheFunction = nullptr;
928 FunctionProcessed = false;
929 ST_DEBUG("end purgeFunction!\n");
932 /// getGlobalSlot - Get the slot number of a global value.
933 int SlotTracker::getGlobalSlot(const GlobalValue *V) {
934 // Check for uninitialized state and do lazy initialization.
937 // Find the value in the module map
938 ValueMap::iterator MI = mMap.find(V);
939 return MI == mMap.end() ? -1 : (int)MI->second;
942 /// getMetadataSlot - Get the slot number of a MDNode.
943 int SlotTracker::getMetadataSlot(const MDNode *N) {
944 // Check for uninitialized state and do lazy initialization.
947 // Find the MDNode in the module map
948 mdn_iterator MI = mdnMap.find(N);
949 return MI == mdnMap.end() ? -1 : (int)MI->second;
953 /// getLocalSlot - Get the slot number for a value that is local to a function.
954 int SlotTracker::getLocalSlot(const Value *V) {
955 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
957 // Check for uninitialized state and do lazy initialization.
960 ValueMap::iterator FI = fMap.find(V);
961 return FI == fMap.end() ? -1 : (int)FI->second;
964 int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
965 // Check for uninitialized state and do lazy initialization.
968 // Find the AttributeSet in the module map.
969 as_iterator AI = asMap.find(AS);
970 return AI == asMap.end() ? -1 : (int)AI->second;
973 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
974 void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
975 assert(V && "Can't insert a null Value into SlotTracker!");
976 assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
977 assert(!V->hasName() && "Doesn't need a slot!");
979 unsigned DestSlot = mNext++;
982 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
984 // G = Global, F = Function, A = Alias, I = IFunc, o = other
985 ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
986 (isa<Function>(V) ? 'F' :
987 (isa<GlobalAlias>(V) ? 'A' :
988 (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
991 /// CreateSlot - Create a new slot for the specified value if it has no name.
992 void SlotTracker::CreateFunctionSlot(const Value *V) {
993 assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
995 unsigned DestSlot = fNext++;
998 // G = Global, F = Function, o = other
999 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1000 DestSlot << " [o]\n");
1003 /// CreateModuleSlot - Insert the specified MDNode* into the slot table.
1004 void SlotTracker::CreateMetadataSlot(const MDNode *N) {
1005 assert(N && "Can't insert a null Value into SlotTracker!");
1007 unsigned DestSlot = mdnNext;
1008 if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1012 // Recursively add any MDNodes referenced by operands.
1013 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
1014 if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1015 CreateMetadataSlot(Op);
1018 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
1019 assert(AS.hasAttributes(AttributeSet::FunctionIndex) &&
1020 "Doesn't need a slot!");
1022 as_iterator I = asMap.find(AS);
1023 if (I != asMap.end())
1026 unsigned DestSlot = asNext++;
1027 asMap[AS] = DestSlot;
1030 //===----------------------------------------------------------------------===//
1031 // AsmWriter Implementation
1032 //===----------------------------------------------------------------------===//
1034 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1035 TypePrinting *TypePrinter,
1036 SlotTracker *Machine,
1037 const Module *Context);
1039 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1040 TypePrinting *TypePrinter,
1041 SlotTracker *Machine, const Module *Context,
1042 bool FromValue = false);
1044 static void writeAtomicRMWOperation(raw_ostream &Out,
1045 AtomicRMWInst::BinOp Op) {
1047 default: Out << " <unknown operation " << Op << ">"; break;
1048 case AtomicRMWInst::Xchg: Out << " xchg"; break;
1049 case AtomicRMWInst::Add: Out << " add"; break;
1050 case AtomicRMWInst::Sub: Out << " sub"; break;
1051 case AtomicRMWInst::And: Out << " and"; break;
1052 case AtomicRMWInst::Nand: Out << " nand"; break;
1053 case AtomicRMWInst::Or: Out << " or"; break;
1054 case AtomicRMWInst::Xor: Out << " xor"; break;
1055 case AtomicRMWInst::Max: Out << " max"; break;
1056 case AtomicRMWInst::Min: Out << " min"; break;
1057 case AtomicRMWInst::UMax: Out << " umax"; break;
1058 case AtomicRMWInst::UMin: Out << " umin"; break;
1062 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
1063 if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
1064 // Unsafe algebra implies all the others, no need to write them all out
1065 if (FPO->hasUnsafeAlgebra())
1068 if (FPO->hasNoNaNs())
1070 if (FPO->hasNoInfs())
1072 if (FPO->hasNoSignedZeros())
1074 if (FPO->hasAllowReciprocal())
1079 if (const OverflowingBinaryOperator *OBO =
1080 dyn_cast<OverflowingBinaryOperator>(U)) {
1081 if (OBO->hasNoUnsignedWrap())
1083 if (OBO->hasNoSignedWrap())
1085 } else if (const PossiblyExactOperator *Div =
1086 dyn_cast<PossiblyExactOperator>(U)) {
1089 } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
1090 if (GEP->isInBounds())
1095 static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
1096 TypePrinting &TypePrinter,
1097 SlotTracker *Machine,
1098 const Module *Context) {
1099 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1100 if (CI->getType()->isIntegerTy(1)) {
1101 Out << (CI->getZExtValue() ? "true" : "false");
1104 Out << CI->getValue();
1108 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1109 if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEsingle() ||
1110 &CFP->getValueAPF().getSemantics() == &APFloat::IEEEdouble()) {
1111 // We would like to output the FP constant value in exponential notation,
1112 // but we cannot do this if doing so will lose precision. Check here to
1113 // make sure that we only output it in exponential format if we can parse
1114 // the value back and get the same value.
1117 bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble();
1118 bool isInf = CFP->getValueAPF().isInfinity();
1119 bool isNaN = CFP->getValueAPF().isNaN();
1120 if (!isInf && !isNaN) {
1121 double Val = isDouble ? CFP->getValueAPF().convertToDouble() :
1122 CFP->getValueAPF().convertToFloat();
1123 SmallString<128> StrVal;
1124 raw_svector_ostream(StrVal) << Val;
1126 // Check to make sure that the stringized number is not some string like
1127 // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1128 // that the string matches the "[-+]?[0-9]" regex.
1130 if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
1131 ((StrVal[0] == '-' || StrVal[0] == '+') &&
1132 (StrVal[1] >= '0' && StrVal[1] <= '9'))) {
1133 // Reparse stringized version!
1134 if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1140 // Otherwise we could not reparse it to exactly the same value, so we must
1141 // output the string in hexadecimal format! Note that loading and storing
1142 // floating point types changes the bits of NaNs on some hosts, notably
1143 // x86, so we must not use these types.
1144 static_assert(sizeof(double) == sizeof(uint64_t),
1145 "assuming that double is 64 bits!");
1146 APFloat apf = CFP->getValueAPF();
1147 // Floats are represented in ASCII IR as double, convert.
1149 apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
1151 Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1155 // Either half, or some form of long double.
1156 // These appear as a magic letter identifying the type, then a
1157 // fixed number of hex digits.
1159 APInt API = CFP->getValueAPF().bitcastToAPInt();
1160 if (&CFP->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended()) {
1162 Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1164 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1167 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEquad()) {
1169 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1171 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1173 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble()) {
1175 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1177 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1179 } else if (&CFP->getValueAPF().getSemantics() == &APFloat::IEEEhalf()) {
1181 Out << format_hex_no_prefix(API.getZExtValue(), 4,
1184 llvm_unreachable("Unsupported floating point type");
1188 if (isa<ConstantAggregateZero>(CV)) {
1189 Out << "zeroinitializer";
1193 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1194 Out << "blockaddress(";
1195 WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
1198 WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
1204 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1205 Type *ETy = CA->getType()->getElementType();
1207 TypePrinter.print(ETy, Out);
1209 WriteAsOperandInternal(Out, CA->getOperand(0),
1210 &TypePrinter, Machine,
1212 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
1214 TypePrinter.print(ETy, Out);
1216 WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
1223 if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
1224 // As a special case, print the array as a string if it is an array of
1225 // i8 with ConstantInt values.
1226 if (CA->isString()) {
1228 PrintEscapedString(CA->getAsString(), Out);
1233 Type *ETy = CA->getType()->getElementType();
1235 TypePrinter.print(ETy, Out);
1237 WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
1238 &TypePrinter, Machine,
1240 for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
1242 TypePrinter.print(ETy, Out);
1244 WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
1252 if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
1253 if (CS->getType()->isPacked())
1256 unsigned N = CS->getNumOperands();
1259 TypePrinter.print(CS->getOperand(0)->getType(), Out);
1262 WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
1265 for (unsigned i = 1; i < N; i++) {
1267 TypePrinter.print(CS->getOperand(i)->getType(), Out);
1270 WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
1277 if (CS->getType()->isPacked())
1282 if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
1283 Type *ETy = CV->getType()->getVectorElementType();
1285 TypePrinter.print(ETy, Out);
1287 WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
1289 for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
1291 TypePrinter.print(ETy, Out);
1293 WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
1300 if (isa<ConstantPointerNull>(CV)) {
1305 if (isa<ConstantTokenNone>(CV)) {
1310 if (isa<UndefValue>(CV)) {
1315 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1316 Out << CE->getOpcodeName();
1317 WriteOptimizationInfo(Out, CE);
1318 if (CE->isCompare())
1319 Out << ' ' << CmpInst::getPredicateName(
1320 static_cast<CmpInst::Predicate>(CE->getPredicate()));
1323 Optional<unsigned> InRangeOp;
1324 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1325 TypePrinter.print(GEP->getSourceElementType(), Out);
1327 InRangeOp = GEP->getInRangeIndex();
1332 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
1333 if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
1335 TypePrinter.print((*OI)->getType(), Out);
1337 WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
1338 if (OI+1 != CE->op_end())
1342 if (CE->hasIndices()) {
1343 ArrayRef<unsigned> Indices = CE->getIndices();
1344 for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1345 Out << ", " << Indices[i];
1350 TypePrinter.print(CE->getType(), Out);
1357 Out << "<placeholder or erroneous Constant>";
1360 static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1361 TypePrinting *TypePrinter, SlotTracker *Machine,
1362 const Module *Context) {
1364 for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
1365 const Metadata *MD = Node->getOperand(mi);
1368 else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1369 Value *V = MDV->getValue();
1370 TypePrinter->print(V->getType(), Out);
1372 WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
1374 WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1384 struct FieldSeparator {
1387 FieldSeparator(const char *Sep = ", ") : Skip(true), Sep(Sep) {}
1389 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
1394 return OS << FS.Sep;
1396 struct MDFieldPrinter {
1399 TypePrinting *TypePrinter;
1400 SlotTracker *Machine;
1401 const Module *Context;
1403 explicit MDFieldPrinter(raw_ostream &Out)
1404 : Out(Out), TypePrinter(nullptr), Machine(nullptr), Context(nullptr) {}
1405 MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
1406 SlotTracker *Machine, const Module *Context)
1407 : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
1409 void printTag(const DINode *N);
1410 void printMacinfoType(const DIMacroNode *N);
1411 void printChecksumKind(const DIFile *N);
1412 void printString(StringRef Name, StringRef Value,
1413 bool ShouldSkipEmpty = true);
1414 void printMetadata(StringRef Name, const Metadata *MD,
1415 bool ShouldSkipNull = true);
1416 template <class IntTy>
1417 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1418 void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
1419 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1420 template <class IntTy, class Stringifier>
1421 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1422 bool ShouldSkipZero = true);
1423 void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1427 void MDFieldPrinter::printTag(const DINode *N) {
1428 Out << FS << "tag: ";
1429 auto Tag = dwarf::TagString(N->getTag());
1436 void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1437 Out << FS << "type: ";
1438 auto Type = dwarf::MacinfoString(N->getMacinfoType());
1442 Out << N->getMacinfoType();
1445 void MDFieldPrinter::printChecksumKind(const DIFile *N) {
1446 if (N->getChecksumKind() == DIFile::CSK_None)
1447 // Skip CSK_None checksum kind.
1449 Out << FS << "checksumkind: " << N->getChecksumKindAsString();
1452 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1453 bool ShouldSkipEmpty) {
1454 if (ShouldSkipEmpty && Value.empty())
1457 Out << FS << Name << ": \"";
1458 PrintEscapedString(Value, Out);
1462 static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1463 TypePrinting *TypePrinter,
1464 SlotTracker *Machine,
1465 const Module *Context) {
1470 WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1473 void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1474 bool ShouldSkipNull) {
1475 if (ShouldSkipNull && !MD)
1478 Out << FS << Name << ": ";
1479 writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1482 template <class IntTy>
1483 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1484 if (ShouldSkipZero && !Int)
1487 Out << FS << Name << ": " << Int;
1490 void MDFieldPrinter::printBool(StringRef Name, bool Value,
1491 Optional<bool> Default) {
1492 if (Default && Value == *Default)
1494 Out << FS << Name << ": " << (Value ? "true" : "false");
1497 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1501 Out << FS << Name << ": ";
1503 SmallVector<DINode::DIFlags, 8> SplitFlags;
1504 auto Extra = DINode::splitFlags(Flags, SplitFlags);
1506 FieldSeparator FlagsFS(" | ");
1507 for (auto F : SplitFlags) {
1508 auto StringF = DINode::getFlagString(F);
1509 assert(!StringF.empty() && "Expected valid flag");
1510 Out << FlagsFS << StringF;
1512 if (Extra || SplitFlags.empty())
1513 Out << FlagsFS << Extra;
1516 void MDFieldPrinter::printEmissionKind(StringRef Name,
1517 DICompileUnit::DebugEmissionKind EK) {
1518 Out << FS << Name << ": " << DICompileUnit::EmissionKindString(EK);
1522 template <class IntTy, class Stringifier>
1523 void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
1524 Stringifier toString, bool ShouldSkipZero) {
1528 Out << FS << Name << ": ";
1529 auto S = toString(Value);
1536 static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
1537 TypePrinting *TypePrinter, SlotTracker *Machine,
1538 const Module *Context) {
1539 Out << "!GenericDINode(";
1540 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1541 Printer.printTag(N);
1542 Printer.printString("header", N->getHeader());
1543 if (N->getNumDwarfOperands()) {
1544 Out << Printer.FS << "operands: {";
1546 for (auto &I : N->dwarf_operands()) {
1548 writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
1555 static void writeDILocation(raw_ostream &Out, const DILocation *DL,
1556 TypePrinting *TypePrinter, SlotTracker *Machine,
1557 const Module *Context) {
1558 Out << "!DILocation(";
1559 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1560 // Always output the line, since 0 is a relevant and important value for it.
1561 Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
1562 Printer.printInt("column", DL->getColumn());
1563 Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
1564 Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
1568 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
1569 TypePrinting *, SlotTracker *, const Module *) {
1570 Out << "!DISubrange(";
1571 MDFieldPrinter Printer(Out);
1572 Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
1573 Printer.printInt("lowerBound", N->getLowerBound());
1577 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
1578 TypePrinting *, SlotTracker *, const Module *) {
1579 Out << "!DIEnumerator(";
1580 MDFieldPrinter Printer(Out);
1581 Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
1582 Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
1586 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
1587 TypePrinting *, SlotTracker *, const Module *) {
1588 Out << "!DIBasicType(";
1589 MDFieldPrinter Printer(Out);
1590 if (N->getTag() != dwarf::DW_TAG_base_type)
1591 Printer.printTag(N);
1592 Printer.printString("name", N->getName());
1593 Printer.printInt("size", N->getSizeInBits());
1594 Printer.printInt("align", N->getAlignInBits());
1595 Printer.printDwarfEnum("encoding", N->getEncoding(),
1596 dwarf::AttributeEncodingString);
1600 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
1601 TypePrinting *TypePrinter, SlotTracker *Machine,
1602 const Module *Context) {
1603 Out << "!DIDerivedType(";
1604 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1605 Printer.printTag(N);
1606 Printer.printString("name", N->getName());
1607 Printer.printMetadata("scope", N->getRawScope());
1608 Printer.printMetadata("file", N->getRawFile());
1609 Printer.printInt("line", N->getLine());
1610 Printer.printMetadata("baseType", N->getRawBaseType(),
1611 /* ShouldSkipNull */ false);
1612 Printer.printInt("size", N->getSizeInBits());
1613 Printer.printInt("align", N->getAlignInBits());
1614 Printer.printInt("offset", N->getOffsetInBits());
1615 Printer.printDIFlags("flags", N->getFlags());
1616 Printer.printMetadata("extraData", N->getRawExtraData());
1620 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
1621 TypePrinting *TypePrinter,
1622 SlotTracker *Machine, const Module *Context) {
1623 Out << "!DICompositeType(";
1624 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1625 Printer.printTag(N);
1626 Printer.printString("name", N->getName());
1627 Printer.printMetadata("scope", N->getRawScope());
1628 Printer.printMetadata("file", N->getRawFile());
1629 Printer.printInt("line", N->getLine());
1630 Printer.printMetadata("baseType", N->getRawBaseType());
1631 Printer.printInt("size", N->getSizeInBits());
1632 Printer.printInt("align", N->getAlignInBits());
1633 Printer.printInt("offset", N->getOffsetInBits());
1634 Printer.printDIFlags("flags", N->getFlags());
1635 Printer.printMetadata("elements", N->getRawElements());
1636 Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
1637 dwarf::LanguageString);
1638 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
1639 Printer.printMetadata("templateParams", N->getRawTemplateParams());
1640 Printer.printString("identifier", N->getIdentifier());
1644 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
1645 TypePrinting *TypePrinter,
1646 SlotTracker *Machine, const Module *Context) {
1647 Out << "!DISubroutineType(";
1648 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1649 Printer.printDIFlags("flags", N->getFlags());
1650 Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
1651 Printer.printMetadata("types", N->getRawTypeArray(),
1652 /* ShouldSkipNull */ false);
1656 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
1657 SlotTracker *, const Module *) {
1659 MDFieldPrinter Printer(Out);
1660 Printer.printString("filename", N->getFilename(),
1661 /* ShouldSkipEmpty */ false);
1662 Printer.printString("directory", N->getDirectory(),
1663 /* ShouldSkipEmpty */ false);
1664 Printer.printChecksumKind(N);
1665 Printer.printString("checksum", N->getChecksum(), /* ShouldSkipEmpty */ true);
1669 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
1670 TypePrinting *TypePrinter, SlotTracker *Machine,
1671 const Module *Context) {
1672 Out << "!DICompileUnit(";
1673 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1674 Printer.printDwarfEnum("language", N->getSourceLanguage(),
1675 dwarf::LanguageString, /* ShouldSkipZero */ false);
1676 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1677 Printer.printString("producer", N->getProducer());
1678 Printer.printBool("isOptimized", N->isOptimized());
1679 Printer.printString("flags", N->getFlags());
1680 Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
1681 /* ShouldSkipZero */ false);
1682 Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
1683 Printer.printEmissionKind("emissionKind", N->getEmissionKind());
1684 Printer.printMetadata("enums", N->getRawEnumTypes());
1685 Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
1686 Printer.printMetadata("globals", N->getRawGlobalVariables());
1687 Printer.printMetadata("imports", N->getRawImportedEntities());
1688 Printer.printMetadata("macros", N->getRawMacros());
1689 Printer.printInt("dwoId", N->getDWOId());
1690 Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
1694 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
1695 TypePrinting *TypePrinter, SlotTracker *Machine,
1696 const Module *Context) {
1697 Out << "!DISubprogram(";
1698 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1699 Printer.printString("name", N->getName());
1700 Printer.printString("linkageName", N->getLinkageName());
1701 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1702 Printer.printMetadata("file", N->getRawFile());
1703 Printer.printInt("line", N->getLine());
1704 Printer.printMetadata("type", N->getRawType());
1705 Printer.printBool("isLocal", N->isLocalToUnit());
1706 Printer.printBool("isDefinition", N->isDefinition());
1707 Printer.printInt("scopeLine", N->getScopeLine());
1708 Printer.printMetadata("containingType", N->getRawContainingType());
1709 Printer.printDwarfEnum("virtuality", N->getVirtuality(),
1710 dwarf::VirtualityString);
1711 if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
1712 N->getVirtualIndex() != 0)
1713 Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
1714 Printer.printInt("thisAdjustment", N->getThisAdjustment());
1715 Printer.printDIFlags("flags", N->getFlags());
1716 Printer.printBool("isOptimized", N->isOptimized());
1717 Printer.printMetadata("unit", N->getRawUnit());
1718 Printer.printMetadata("templateParams", N->getRawTemplateParams());
1719 Printer.printMetadata("declaration", N->getRawDeclaration());
1720 Printer.printMetadata("variables", N->getRawVariables());
1724 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
1725 TypePrinting *TypePrinter, SlotTracker *Machine,
1726 const Module *Context) {
1727 Out << "!DILexicalBlock(";
1728 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1729 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1730 Printer.printMetadata("file", N->getRawFile());
1731 Printer.printInt("line", N->getLine());
1732 Printer.printInt("column", N->getColumn());
1736 static void writeDILexicalBlockFile(raw_ostream &Out,
1737 const DILexicalBlockFile *N,
1738 TypePrinting *TypePrinter,
1739 SlotTracker *Machine,
1740 const Module *Context) {
1741 Out << "!DILexicalBlockFile(";
1742 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1743 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1744 Printer.printMetadata("file", N->getRawFile());
1745 Printer.printInt("discriminator", N->getDiscriminator(),
1746 /* ShouldSkipZero */ false);
1750 static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
1751 TypePrinting *TypePrinter, SlotTracker *Machine,
1752 const Module *Context) {
1753 Out << "!DINamespace(";
1754 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1755 Printer.printString("name", N->getName());
1756 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1757 Printer.printMetadata("file", N->getRawFile());
1758 Printer.printInt("line", N->getLine());
1759 Printer.printBool("exportSymbols", N->getExportSymbols(), false);
1763 static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
1764 TypePrinting *TypePrinter, SlotTracker *Machine,
1765 const Module *Context) {
1767 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1768 Printer.printMacinfoType(N);
1769 Printer.printInt("line", N->getLine());
1770 Printer.printString("name", N->getName());
1771 Printer.printString("value", N->getValue());
1775 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
1776 TypePrinting *TypePrinter, SlotTracker *Machine,
1777 const Module *Context) {
1778 Out << "!DIMacroFile(";
1779 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1780 Printer.printInt("line", N->getLine());
1781 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1782 Printer.printMetadata("nodes", N->getRawElements());
1786 static void writeDIModule(raw_ostream &Out, const DIModule *N,
1787 TypePrinting *TypePrinter, SlotTracker *Machine,
1788 const Module *Context) {
1789 Out << "!DIModule(";
1790 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1791 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1792 Printer.printString("name", N->getName());
1793 Printer.printString("configMacros", N->getConfigurationMacros());
1794 Printer.printString("includePath", N->getIncludePath());
1795 Printer.printString("isysroot", N->getISysRoot());
1800 static void writeDITemplateTypeParameter(raw_ostream &Out,
1801 const DITemplateTypeParameter *N,
1802 TypePrinting *TypePrinter,
1803 SlotTracker *Machine,
1804 const Module *Context) {
1805 Out << "!DITemplateTypeParameter(";
1806 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1807 Printer.printString("name", N->getName());
1808 Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
1812 static void writeDITemplateValueParameter(raw_ostream &Out,
1813 const DITemplateValueParameter *N,
1814 TypePrinting *TypePrinter,
1815 SlotTracker *Machine,
1816 const Module *Context) {
1817 Out << "!DITemplateValueParameter(";
1818 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1819 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
1820 Printer.printTag(N);
1821 Printer.printString("name", N->getName());
1822 Printer.printMetadata("type", N->getRawType());
1823 Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
1827 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
1828 TypePrinting *TypePrinter,
1829 SlotTracker *Machine, const Module *Context) {
1830 Out << "!DIGlobalVariable(";
1831 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1832 Printer.printString("name", N->getName());
1833 Printer.printString("linkageName", N->getLinkageName());
1834 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1835 Printer.printMetadata("file", N->getRawFile());
1836 Printer.printInt("line", N->getLine());
1837 Printer.printMetadata("type", N->getRawType());
1838 Printer.printBool("isLocal", N->isLocalToUnit());
1839 Printer.printBool("isDefinition", N->isDefinition());
1840 Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
1841 Printer.printInt("align", N->getAlignInBits());
1845 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
1846 TypePrinting *TypePrinter,
1847 SlotTracker *Machine, const Module *Context) {
1848 Out << "!DILocalVariable(";
1849 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1850 Printer.printString("name", N->getName());
1851 Printer.printInt("arg", N->getArg());
1852 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1853 Printer.printMetadata("file", N->getRawFile());
1854 Printer.printInt("line", N->getLine());
1855 Printer.printMetadata("type", N->getRawType());
1856 Printer.printDIFlags("flags", N->getFlags());
1857 Printer.printInt("align", N->getAlignInBits());
1861 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
1862 TypePrinting *TypePrinter, SlotTracker *Machine,
1863 const Module *Context) {
1864 Out << "!DIExpression(";
1867 for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
1868 auto OpStr = dwarf::OperationEncodingString(I->getOp());
1869 assert(!OpStr.empty() && "Expected valid opcode");
1872 for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
1873 Out << FS << I->getArg(A);
1876 for (const auto &I : N->getElements())
1882 static void writeDIGlobalVariableExpression(raw_ostream &Out,
1883 const DIGlobalVariableExpression *N,
1884 TypePrinting *TypePrinter,
1885 SlotTracker *Machine,
1886 const Module *Context) {
1887 Out << "!DIGlobalVariableExpression(";
1888 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1889 Printer.printMetadata("var", N->getVariable());
1890 Printer.printMetadata("expr", N->getExpression());
1894 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
1895 TypePrinting *TypePrinter, SlotTracker *Machine,
1896 const Module *Context) {
1897 Out << "!DIObjCProperty(";
1898 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1899 Printer.printString("name", N->getName());
1900 Printer.printMetadata("file", N->getRawFile());
1901 Printer.printInt("line", N->getLine());
1902 Printer.printString("setter", N->getSetterName());
1903 Printer.printString("getter", N->getGetterName());
1904 Printer.printInt("attributes", N->getAttributes());
1905 Printer.printMetadata("type", N->getRawType());
1909 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
1910 TypePrinting *TypePrinter,
1911 SlotTracker *Machine, const Module *Context) {
1912 Out << "!DIImportedEntity(";
1913 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1914 Printer.printTag(N);
1915 Printer.printString("name", N->getName());
1916 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1917 Printer.printMetadata("entity", N->getRawEntity());
1918 Printer.printInt("line", N->getLine());
1923 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
1924 TypePrinting *TypePrinter,
1925 SlotTracker *Machine,
1926 const Module *Context) {
1927 if (Node->isDistinct())
1929 else if (Node->isTemporary())
1930 Out << "<temporary!> "; // Handle broken code.
1932 switch (Node->getMetadataID()) {
1934 llvm_unreachable("Expected uniquable MDNode");
1935 #define HANDLE_MDNODE_LEAF(CLASS) \
1936 case Metadata::CLASS##Kind: \
1937 write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
1939 #include "llvm/IR/Metadata.def"
1943 // Full implementation of printing a Value as an operand with support for
1944 // TypePrinting, etc.
1945 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1946 TypePrinting *TypePrinter,
1947 SlotTracker *Machine,
1948 const Module *Context) {
1950 PrintLLVMName(Out, V);
1954 const Constant *CV = dyn_cast<Constant>(V);
1955 if (CV && !isa<GlobalValue>(CV)) {
1956 assert(TypePrinter && "Constants require TypePrinting!");
1957 WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
1961 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1963 if (IA->hasSideEffects())
1964 Out << "sideeffect ";
1965 if (IA->isAlignStack())
1966 Out << "alignstack ";
1967 // We don't emit the AD_ATT dialect as it's the assumed default.
1968 if (IA->getDialect() == InlineAsm::AD_Intel)
1969 Out << "inteldialect ";
1971 PrintEscapedString(IA->getAsmString(), Out);
1973 PrintEscapedString(IA->getConstraintString(), Out);
1978 if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
1979 WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
1980 Context, /* FromValue */ true);
1986 // If we have a SlotTracker, use it.
1988 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
1989 Slot = Machine->getGlobalSlot(GV);
1992 Slot = Machine->getLocalSlot(V);
1994 // If the local value didn't succeed, then we may be referring to a value
1995 // from a different function. Translate it, as this can happen when using
1996 // address of blocks.
1998 if ((Machine = createSlotTracker(V))) {
1999 Slot = Machine->getLocalSlot(V);
2003 } else if ((Machine = createSlotTracker(V))) {
2004 // Otherwise, create one to get the # and then destroy it.
2005 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2006 Slot = Machine->getGlobalSlot(GV);
2009 Slot = Machine->getLocalSlot(V);
2018 Out << Prefix << Slot;
2023 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2024 TypePrinting *TypePrinter,
2025 SlotTracker *Machine, const Module *Context,
2027 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2028 std::unique_ptr<SlotTracker> MachineStorage;
2030 MachineStorage = make_unique<SlotTracker>(Context);
2031 Machine = MachineStorage.get();
2033 int Slot = Machine->getMetadataSlot(N);
2035 // Give the pointer value instead of "badref", since this comes up all
2036 // the time when debugging.
2037 Out << "<" << N << ">";
2043 if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2045 PrintEscapedString(MDS->getString(), Out);
2050 auto *V = cast<ValueAsMetadata>(MD);
2051 assert(TypePrinter && "TypePrinter required for metadata values");
2052 assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2053 "Unexpected function-local metadata outside of value argument");
2055 TypePrinter->print(V->getValue()->getType(), Out);
2057 WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2061 class AssemblyWriter {
2062 formatted_raw_ostream &Out;
2063 const Module *TheModule;
2064 std::unique_ptr<SlotTracker> SlotTrackerStorage;
2065 SlotTracker &Machine;
2066 TypePrinting TypePrinter;
2067 AssemblyAnnotationWriter *AnnotationWriter;
2068 SetVector<const Comdat *> Comdats;
2070 bool ShouldPreserveUseListOrder;
2071 UseListOrderStack UseListOrders;
2072 SmallVector<StringRef, 8> MDNames;
2075 /// Construct an AssemblyWriter with an external SlotTracker
2076 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2077 AssemblyAnnotationWriter *AAW, bool IsForDebug,
2078 bool ShouldPreserveUseListOrder = false);
2080 void printMDNodeBody(const MDNode *MD);
2081 void printNamedMDNode(const NamedMDNode *NMD);
2083 void printModule(const Module *M);
2085 void writeOperand(const Value *Op, bool PrintType);
2086 void writeParamOperand(const Value *Operand, AttributeSet Attrs,unsigned Idx);
2087 void writeOperandBundles(ImmutableCallSite CS);
2088 void writeAtomic(AtomicOrdering Ordering, SynchronizationScope SynchScope);
2089 void writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
2090 AtomicOrdering FailureOrdering,
2091 SynchronizationScope SynchScope);
2093 void writeAllMDNodes();
2094 void writeMDNode(unsigned Slot, const MDNode *Node);
2095 void writeAllAttributeGroups();
2097 void printTypeIdentities();
2098 void printGlobal(const GlobalVariable *GV);
2099 void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
2100 void printComdat(const Comdat *C);
2101 void printFunction(const Function *F);
2102 void printArgument(const Argument *FA, AttributeSet Attrs, unsigned Idx);
2103 void printBasicBlock(const BasicBlock *BB);
2104 void printInstructionLine(const Instruction &I);
2105 void printInstruction(const Instruction &I);
2107 void printUseListOrder(const UseListOrder &Order);
2108 void printUseLists(const Function *F);
2111 /// \brief Print out metadata attachments.
2112 void printMetadataAttachments(
2113 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2114 StringRef Separator);
2116 // printInfoComment - Print a little comment after the instruction indicating
2117 // which slot it occupies.
2118 void printInfoComment(const Value &V);
2120 // printGCRelocateComment - print comment after call to the gc.relocate
2121 // intrinsic indicating base and derived pointer names.
2122 void printGCRelocateComment(const GCRelocateInst &Relocate);
2126 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2127 const Module *M, AssemblyAnnotationWriter *AAW,
2128 bool IsForDebug, bool ShouldPreserveUseListOrder)
2129 : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
2130 IsForDebug(IsForDebug),
2131 ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2134 TypePrinter.incorporateTypes(*TheModule);
2135 for (const GlobalObject &GO : TheModule->global_objects())
2136 if (const Comdat *C = GO.getComdat())
2140 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2142 Out << "<null operand!>";
2146 TypePrinter.print(Operand->getType(), Out);
2149 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2152 void AssemblyWriter::writeAtomic(AtomicOrdering Ordering,
2153 SynchronizationScope SynchScope) {
2154 if (Ordering == AtomicOrdering::NotAtomic)
2157 switch (SynchScope) {
2158 case SingleThread: Out << " singlethread"; break;
2159 case CrossThread: break;
2162 Out << " " << toIRString(Ordering);
2165 void AssemblyWriter::writeAtomicCmpXchg(AtomicOrdering SuccessOrdering,
2166 AtomicOrdering FailureOrdering,
2167 SynchronizationScope SynchScope) {
2168 assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2169 FailureOrdering != AtomicOrdering::NotAtomic);
2171 switch (SynchScope) {
2172 case SingleThread: Out << " singlethread"; break;
2173 case CrossThread: break;
2176 Out << " " << toIRString(SuccessOrdering);
2177 Out << " " << toIRString(FailureOrdering);
2180 void AssemblyWriter::writeParamOperand(const Value *Operand,
2181 AttributeSet Attrs, unsigned Idx) {
2183 Out << "<null operand!>";
2188 TypePrinter.print(Operand->getType(), Out);
2189 // Print parameter attributes list
2190 if (Attrs.hasAttributes(Idx))
2191 Out << ' ' << Attrs.getAsString(Idx);
2193 // Print the operand
2194 WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2197 void AssemblyWriter::writeOperandBundles(ImmutableCallSite CS) {
2198 if (!CS.hasOperandBundles())
2203 bool FirstBundle = true;
2204 for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
2205 OperandBundleUse BU = CS.getOperandBundleAt(i);
2209 FirstBundle = false;
2212 PrintEscapedString(BU.getTagName(), Out);
2217 bool FirstInput = true;
2218 for (const auto &Input : BU.Inputs) {
2223 TypePrinter.print(Input->getType(), Out);
2225 WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
2234 void AssemblyWriter::printModule(const Module *M) {
2235 Machine.initialize();
2237 if (ShouldPreserveUseListOrder)
2238 UseListOrders = predictUseListOrder(M);
2240 if (!M->getModuleIdentifier().empty() &&
2241 // Don't print the ID if it will start a new line (which would
2242 // require a comment char before it).
2243 M->getModuleIdentifier().find('\n') == std::string::npos)
2244 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
2246 if (!M->getSourceFileName().empty()) {
2247 Out << "source_filename = \"";
2248 PrintEscapedString(M->getSourceFileName(), Out);
2252 const std::string &DL = M->getDataLayoutStr();
2254 Out << "target datalayout = \"" << DL << "\"\n";
2255 if (!M->getTargetTriple().empty())
2256 Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
2258 if (!M->getModuleInlineAsm().empty()) {
2261 // Split the string into lines, to make it easier to read the .ll file.
2262 StringRef Asm = M->getModuleInlineAsm();
2265 std::tie(Front, Asm) = Asm.split('\n');
2267 // We found a newline, print the portion of the asm string from the
2268 // last newline up to this newline.
2269 Out << "module asm \"";
2270 PrintEscapedString(Front, Out);
2272 } while (!Asm.empty());
2275 printTypeIdentities();
2277 // Output all comdats.
2278 if (!Comdats.empty())
2280 for (const Comdat *C : Comdats) {
2282 if (C != Comdats.back())
2286 // Output all globals.
2287 if (!M->global_empty()) Out << '\n';
2288 for (const GlobalVariable &GV : M->globals()) {
2289 printGlobal(&GV); Out << '\n';
2292 // Output all aliases.
2293 if (!M->alias_empty()) Out << "\n";
2294 for (const GlobalAlias &GA : M->aliases())
2295 printIndirectSymbol(&GA);
2297 // Output all ifuncs.
2298 if (!M->ifunc_empty()) Out << "\n";
2299 for (const GlobalIFunc &GI : M->ifuncs())
2300 printIndirectSymbol(&GI);
2302 // Output global use-lists.
2303 printUseLists(nullptr);
2305 // Output all of the functions.
2306 for (const Function &F : *M)
2308 assert(UseListOrders.empty() && "All use-lists should have been consumed");
2310 // Output all attribute groups.
2311 if (!Machine.as_empty()) {
2313 writeAllAttributeGroups();
2316 // Output named metadata.
2317 if (!M->named_metadata_empty()) Out << '\n';
2319 for (const NamedMDNode &Node : M->named_metadata())
2320 printNamedMDNode(&Node);
2323 if (!Machine.mdn_empty()) {
2329 static void printMetadataIdentifier(StringRef Name,
2330 formatted_raw_ostream &Out) {
2332 Out << "<empty name> ";
2334 if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
2335 Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
2338 Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
2339 for (unsigned i = 1, e = Name.size(); i != e; ++i) {
2340 unsigned char C = Name[i];
2341 if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
2342 C == '.' || C == '_')
2345 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
2350 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
2352 printMetadataIdentifier(NMD->getName(), Out);
2354 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2357 int Slot = Machine.getMetadataSlot(NMD->getOperand(i));
2366 static const char *getLinkagePrintName(GlobalValue::LinkageTypes LT) {
2368 case GlobalValue::ExternalLinkage:
2370 case GlobalValue::PrivateLinkage:
2372 case GlobalValue::InternalLinkage:
2374 case GlobalValue::LinkOnceAnyLinkage:
2376 case GlobalValue::LinkOnceODRLinkage:
2377 return "linkonce_odr ";
2378 case GlobalValue::WeakAnyLinkage:
2380 case GlobalValue::WeakODRLinkage:
2382 case GlobalValue::CommonLinkage:
2384 case GlobalValue::AppendingLinkage:
2385 return "appending ";
2386 case GlobalValue::ExternalWeakLinkage:
2387 return "extern_weak ";
2388 case GlobalValue::AvailableExternallyLinkage:
2389 return "available_externally ";
2391 llvm_unreachable("invalid linkage");
2394 static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
2395 formatted_raw_ostream &Out) {
2397 case GlobalValue::DefaultVisibility: break;
2398 case GlobalValue::HiddenVisibility: Out << "hidden "; break;
2399 case GlobalValue::ProtectedVisibility: Out << "protected "; break;
2403 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
2404 formatted_raw_ostream &Out) {
2406 case GlobalValue::DefaultStorageClass: break;
2407 case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
2408 case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
2412 static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM,
2413 formatted_raw_ostream &Out) {
2415 case GlobalVariable::NotThreadLocal:
2417 case GlobalVariable::GeneralDynamicTLSModel:
2418 Out << "thread_local ";
2420 case GlobalVariable::LocalDynamicTLSModel:
2421 Out << "thread_local(localdynamic) ";
2423 case GlobalVariable::InitialExecTLSModel:
2424 Out << "thread_local(initialexec) ";
2426 case GlobalVariable::LocalExecTLSModel:
2427 Out << "thread_local(localexec) ";
2432 static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) {
2434 case GlobalVariable::UnnamedAddr::None:
2436 case GlobalVariable::UnnamedAddr::Local:
2437 return "local_unnamed_addr";
2438 case GlobalVariable::UnnamedAddr::Global:
2439 return "unnamed_addr";
2441 llvm_unreachable("Unknown UnnamedAddr");
2444 static void maybePrintComdat(formatted_raw_ostream &Out,
2445 const GlobalObject &GO) {
2446 const Comdat *C = GO.getComdat();
2450 if (isa<GlobalVariable>(GO))
2454 if (GO.getName() == C->getName())
2458 PrintLLVMName(Out, C->getName(), ComdatPrefix);
2462 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
2463 if (GV->isMaterializable())
2464 Out << "; Materializable\n";
2466 WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
2469 if (!GV->hasInitializer() && GV->hasExternalLinkage())
2472 Out << getLinkagePrintName(GV->getLinkage());
2473 PrintVisibility(GV->getVisibility(), Out);
2474 PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
2475 PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
2476 StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
2480 if (unsigned AddressSpace = GV->getType()->getAddressSpace())
2481 Out << "addrspace(" << AddressSpace << ") ";
2482 if (GV->isExternallyInitialized()) Out << "externally_initialized ";
2483 Out << (GV->isConstant() ? "constant " : "global ");
2484 TypePrinter.print(GV->getValueType(), Out);
2486 if (GV->hasInitializer()) {
2488 writeOperand(GV->getInitializer(), false);
2491 if (GV->hasSection()) {
2492 Out << ", section \"";
2493 PrintEscapedString(GV->getSection(), Out);
2496 maybePrintComdat(Out, *GV);
2497 if (GV->getAlignment())
2498 Out << ", align " << GV->getAlignment();
2500 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2501 GV->getAllMetadata(MDs);
2502 printMetadataAttachments(MDs, ", ");
2504 printInfoComment(*GV);
2507 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
2508 if (GIS->isMaterializable())
2509 Out << "; Materializable\n";
2511 WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
2514 Out << getLinkagePrintName(GIS->getLinkage());
2515 PrintVisibility(GIS->getVisibility(), Out);
2516 PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
2517 PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
2518 StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
2522 if (isa<GlobalAlias>(GIS))
2524 else if (isa<GlobalIFunc>(GIS))
2527 llvm_unreachable("Not an alias or ifunc!");
2529 TypePrinter.print(GIS->getValueType(), Out);
2533 const Constant *IS = GIS->getIndirectSymbol();
2536 TypePrinter.print(GIS->getType(), Out);
2537 Out << " <<NULL ALIASEE>>";
2539 writeOperand(IS, !isa<ConstantExpr>(IS));
2542 printInfoComment(*GIS);
2546 void AssemblyWriter::printComdat(const Comdat *C) {
2550 void AssemblyWriter::printTypeIdentities() {
2551 if (TypePrinter.NumberedTypes.empty() &&
2552 TypePrinter.NamedTypes.empty())
2557 // We know all the numbers that each type is used and we know that it is a
2558 // dense assignment. Convert the map to an index table.
2559 std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
2560 for (DenseMap<StructType*, unsigned>::iterator I =
2561 TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
2563 assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?");
2564 NumberedTypes[I->second] = I->first;
2567 // Emit all numbered types.
2568 for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
2569 Out << '%' << i << " = type ";
2571 // Make sure we print out at least one level of the type structure, so
2572 // that we do not get %2 = type %2
2573 TypePrinter.printStructBody(NumberedTypes[i], Out);
2577 for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) {
2578 PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix);
2581 // Make sure we print out at least one level of the type structure, so
2582 // that we do not get %FILE = type %FILE
2583 TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
2588 /// printFunction - Print all aspects of a function.
2590 void AssemblyWriter::printFunction(const Function *F) {
2591 // Print out the return type and name.
2594 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
2596 if (F->isMaterializable())
2597 Out << "; Materializable\n";
2599 const AttributeSet &Attrs = F->getAttributes();
2600 if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) {
2601 AttributeSet AS = Attrs.getFnAttributes();
2602 std::string AttrStr;
2605 for (unsigned E = AS.getNumSlots(); Idx != E; ++Idx)
2606 if (AS.getSlotIndex(Idx) == AttributeSet::FunctionIndex)
2609 for (AttributeSet::iterator I = AS.begin(Idx), E = AS.end(Idx);
2611 Attribute Attr = *I;
2612 if (!Attr.isStringAttribute()) {
2613 if (!AttrStr.empty()) AttrStr += ' ';
2614 AttrStr += Attr.getAsString();
2618 if (!AttrStr.empty())
2619 Out << "; Function Attrs: " << AttrStr << '\n';
2622 Machine.incorporateFunction(F);
2624 if (F->isDeclaration()) {
2626 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2627 F->getAllMetadata(MDs);
2628 printMetadataAttachments(MDs, " ");
2633 Out << getLinkagePrintName(F->getLinkage());
2634 PrintVisibility(F->getVisibility(), Out);
2635 PrintDLLStorageClass(F->getDLLStorageClass(), Out);
2637 // Print the calling convention.
2638 if (F->getCallingConv() != CallingConv::C) {
2639 PrintCallingConv(F->getCallingConv(), Out);
2643 FunctionType *FT = F->getFunctionType();
2644 if (Attrs.hasAttributes(AttributeSet::ReturnIndex))
2645 Out << Attrs.getAsString(AttributeSet::ReturnIndex) << ' ';
2646 TypePrinter.print(F->getReturnType(), Out);
2648 WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
2651 // Loop over the arguments, printing them...
2652 if (F->isDeclaration() && !IsForDebug) {
2653 // We're only interested in the type here - don't print argument names.
2654 for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
2655 // Insert commas as we go... the first arg doesn't get a comma
2659 TypePrinter.print(FT->getParamType(I), Out);
2661 if (Attrs.hasAttributes(I + 1))
2662 Out << ' ' << Attrs.getAsString(I + 1);
2665 // The arguments are meaningful here, print them in detail.
2667 for (const Argument &Arg : F->args()) {
2668 // Insert commas as we go... the first arg doesn't get a comma
2671 printArgument(&Arg, Attrs, Idx++);
2675 // Finish printing arguments...
2676 if (FT->isVarArg()) {
2677 if (FT->getNumParams()) Out << ", ";
2678 Out << "..."; // Output varargs portion of signature!
2681 StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
2684 if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
2685 Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
2686 if (F->hasSection()) {
2687 Out << " section \"";
2688 PrintEscapedString(F->getSection(), Out);
2691 maybePrintComdat(Out, *F);
2692 if (F->getAlignment())
2693 Out << " align " << F->getAlignment();
2695 Out << " gc \"" << F->getGC() << '"';
2696 if (F->hasPrefixData()) {
2698 writeOperand(F->getPrefixData(), true);
2700 if (F->hasPrologueData()) {
2701 Out << " prologue ";
2702 writeOperand(F->getPrologueData(), true);
2704 if (F->hasPersonalityFn()) {
2705 Out << " personality ";
2706 writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
2709 if (F->isDeclaration()) {
2712 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2713 F->getAllMetadata(MDs);
2714 printMetadataAttachments(MDs, " ");
2717 // Output all of the function's basic blocks.
2718 for (const BasicBlock &BB : *F)
2719 printBasicBlock(&BB);
2721 // Output the function's use-lists.
2727 Machine.purgeFunction();
2730 /// printArgument - This member is called for every argument that is passed into
2731 /// the function. Simply print it out
2733 void AssemblyWriter::printArgument(const Argument *Arg,
2734 AttributeSet Attrs, unsigned Idx) {
2736 TypePrinter.print(Arg->getType(), Out);
2738 // Output parameter attributes list
2739 if (Attrs.hasAttributes(Idx))
2740 Out << ' ' << Attrs.getAsString(Idx);
2742 // Output name, if available...
2743 if (Arg->hasName()) {
2745 PrintLLVMName(Out, Arg);
2749 /// printBasicBlock - This member is called for each basic block in a method.
2751 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
2752 if (BB->hasName()) { // Print out the label if it exists...
2754 PrintLLVMName(Out, BB->getName(), LabelPrefix);
2756 } else if (!BB->use_empty()) { // Don't print block # of no uses...
2757 Out << "\n; <label>:";
2758 int Slot = Machine.getLocalSlot(BB);
2765 if (!BB->getParent()) {
2766 Out.PadToColumn(50);
2767 Out << "; Error: Block without parent!";
2768 } else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
2769 // Output predecessors for the block.
2770 Out.PadToColumn(50);
2772 const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
2775 Out << " No predecessors!";
2778 writeOperand(*PI, false);
2779 for (++PI; PI != PE; ++PI) {
2781 writeOperand(*PI, false);
2788 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
2790 // Output all of the instructions in the basic block...
2791 for (const Instruction &I : *BB) {
2792 printInstructionLine(I);
2795 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
2798 /// printInstructionLine - Print an instruction and a newline character.
2799 void AssemblyWriter::printInstructionLine(const Instruction &I) {
2800 printInstruction(I);
2804 /// printGCRelocateComment - print comment after call to the gc.relocate
2805 /// intrinsic indicating base and derived pointer names.
2806 void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
2808 writeOperand(Relocate.getBasePtr(), false);
2810 writeOperand(Relocate.getDerivedPtr(), false);
2814 /// printInfoComment - Print a little comment after the instruction indicating
2815 /// which slot it occupies.
2817 void AssemblyWriter::printInfoComment(const Value &V) {
2818 if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
2819 printGCRelocateComment(*Relocate);
2821 if (AnnotationWriter)
2822 AnnotationWriter->printInfoComment(V, Out);
2825 // This member is called for each Instruction in a function..
2826 void AssemblyWriter::printInstruction(const Instruction &I) {
2827 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
2829 // Print out indentation for an instruction.
2832 // Print out name if it exists...
2834 PrintLLVMName(Out, &I);
2836 } else if (!I.getType()->isVoidTy()) {
2837 // Print out the def slot taken.
2838 int SlotNum = Machine.getLocalSlot(&I);
2840 Out << "<badref> = ";
2842 Out << '%' << SlotNum << " = ";
2845 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
2846 if (CI->isMustTailCall())
2848 else if (CI->isTailCall())
2850 else if (CI->isNoTailCall())
2854 // Print out the opcode...
2855 Out << I.getOpcodeName();
2857 // If this is an atomic load or store, print out the atomic marker.
2858 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
2859 (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
2862 if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
2865 // If this is a volatile operation, print out the volatile marker.
2866 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
2867 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
2868 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
2869 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
2872 // Print out optimization information.
2873 WriteOptimizationInfo(Out, &I);
2875 // Print out the compare instruction predicates
2876 if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
2877 Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
2879 // Print out the atomicrmw operation
2880 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
2881 writeAtomicRMWOperation(Out, RMWI->getOperation());
2883 // Print out the type of the operands...
2884 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
2886 // Special case conditional branches to swizzle the condition out to the front
2887 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
2888 const BranchInst &BI(cast<BranchInst>(I));
2890 writeOperand(BI.getCondition(), true);
2892 writeOperand(BI.getSuccessor(0), true);
2894 writeOperand(BI.getSuccessor(1), true);
2896 } else if (isa<SwitchInst>(I)) {
2897 const SwitchInst& SI(cast<SwitchInst>(I));
2898 // Special case switch instruction to get formatting nice and correct.
2900 writeOperand(SI.getCondition(), true);
2902 writeOperand(SI.getDefaultDest(), true);
2904 for (SwitchInst::ConstCaseIt i = SI.case_begin(), e = SI.case_end();
2907 writeOperand(i.getCaseValue(), true);
2909 writeOperand(i.getCaseSuccessor(), true);
2912 } else if (isa<IndirectBrInst>(I)) {
2913 // Special case indirectbr instruction to get formatting nice and correct.
2915 writeOperand(Operand, true);
2918 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
2921 writeOperand(I.getOperand(i), true);
2924 } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
2926 TypePrinter.print(I.getType(), Out);
2929 for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
2930 if (op) Out << ", ";
2932 writeOperand(PN->getIncomingValue(op), false); Out << ", ";
2933 writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
2935 } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
2937 writeOperand(I.getOperand(0), true);
2938 for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
2940 } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
2942 writeOperand(I.getOperand(0), true); Out << ", ";
2943 writeOperand(I.getOperand(1), true);
2944 for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
2946 } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
2948 TypePrinter.print(I.getType(), Out);
2949 if (LPI->isCleanup() || LPI->getNumClauses() != 0)
2952 if (LPI->isCleanup())
2955 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
2956 if (i != 0 || LPI->isCleanup()) Out << "\n";
2957 if (LPI->isCatch(i))
2962 writeOperand(LPI->getClause(i), true);
2964 } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
2966 writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
2969 for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
2972 writeOperand(PadBB, /*PrintType=*/true);
2976 if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
2977 writeOperand(UnwindDest, /*PrintType=*/true);
2980 } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
2982 writeOperand(FPI->getParentPad(), /*PrintType=*/false);
2984 for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
2988 writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
2991 } else if (isa<ReturnInst>(I) && !Operand) {
2993 } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
2995 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
2998 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
2999 } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3001 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3004 if (CRI->hasUnwindDest())
3005 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3008 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3009 // Print the calling convention being used.
3010 if (CI->getCallingConv() != CallingConv::C) {
3012 PrintCallingConv(CI->getCallingConv(), Out);
3015 Operand = CI->getCalledValue();
3016 FunctionType *FTy = CI->getFunctionType();
3017 Type *RetTy = FTy->getReturnType();
3018 const AttributeSet &PAL = CI->getAttributes();
3020 if (PAL.hasAttributes(AttributeSet::ReturnIndex))
3021 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex);
3023 // If possible, print out the short form of the call instruction. We can
3024 // only do this if the first argument is a pointer to a nonvararg function,
3025 // and if the return type is not a pointer to a function.
3028 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3030 writeOperand(Operand, false);
3032 for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
3035 writeParamOperand(CI->getArgOperand(op), PAL, op + 1);
3038 // Emit an ellipsis if this is a musttail call in a vararg function. This
3039 // is only to aid readability, musttail calls forward varargs by default.
3040 if (CI->isMustTailCall() && CI->getParent() &&
3041 CI->getParent()->getParent() &&
3042 CI->getParent()->getParent()->isVarArg())
3046 if (PAL.hasAttributes(AttributeSet::FunctionIndex))
3047 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3049 writeOperandBundles(CI);
3051 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3052 Operand = II->getCalledValue();
3053 FunctionType *FTy = II->getFunctionType();
3054 Type *RetTy = FTy->getReturnType();
3055 const AttributeSet &PAL = II->getAttributes();
3057 // Print the calling convention being used.
3058 if (II->getCallingConv() != CallingConv::C) {
3060 PrintCallingConv(II->getCallingConv(), Out);
3063 if (PAL.hasAttributes(AttributeSet::ReturnIndex))
3064 Out << ' ' << PAL.getAsString(AttributeSet::ReturnIndex);
3066 // If possible, print out the short form of the invoke instruction. We can
3067 // only do this if the first argument is a pointer to a nonvararg function,
3068 // and if the return type is not a pointer to a function.
3071 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3073 writeOperand(Operand, false);
3075 for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
3078 writeParamOperand(II->getArgOperand(op), PAL, op + 1);
3082 if (PAL.hasAttributes(AttributeSet::FunctionIndex))
3083 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3085 writeOperandBundles(II);
3088 writeOperand(II->getNormalDest(), true);
3090 writeOperand(II->getUnwindDest(), true);
3092 } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3094 if (AI->isUsedWithInAlloca())
3096 if (AI->isSwiftError())
3097 Out << "swifterror ";
3098 TypePrinter.print(AI->getAllocatedType(), Out);
3100 // Explicitly write the array size if the code is broken, if it's an array
3101 // allocation, or if the type is not canonical for scalar allocations. The
3102 // latter case prevents the type from mutating when round-tripping through
3104 if (!AI->getArraySize() || AI->isArrayAllocation() ||
3105 !AI->getArraySize()->getType()->isIntegerTy(32)) {
3107 writeOperand(AI->getArraySize(), true);
3109 if (AI->getAlignment()) {
3110 Out << ", align " << AI->getAlignment();
3112 } else if (isa<CastInst>(I)) {
3115 writeOperand(Operand, true); // Work with broken code
3118 TypePrinter.print(I.getType(), Out);
3119 } else if (isa<VAArgInst>(I)) {
3122 writeOperand(Operand, true); // Work with broken code
3125 TypePrinter.print(I.getType(), Out);
3126 } else if (Operand) { // Print the normal way.
3127 if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
3129 TypePrinter.print(GEP->getSourceElementType(), Out);
3131 } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
3133 TypePrinter.print(LI->getType(), Out);
3137 // PrintAllTypes - Instructions who have operands of all the same type
3138 // omit the type from all but the first operand. If the instruction has
3139 // different type operands (for example br), then they are all printed.
3140 bool PrintAllTypes = false;
3141 Type *TheType = Operand->getType();
3143 // Select, Store and ShuffleVector always print all types.
3144 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3145 || isa<ReturnInst>(I)) {
3146 PrintAllTypes = true;
3148 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
3149 Operand = I.getOperand(i);
3150 // note that Operand shouldn't be null, but the test helps make dump()
3151 // more tolerant of malformed IR
3152 if (Operand && Operand->getType() != TheType) {
3153 PrintAllTypes = true; // We have differing types! Print them all!
3159 if (!PrintAllTypes) {
3161 TypePrinter.print(TheType, Out);
3165 for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
3167 writeOperand(I.getOperand(i), PrintAllTypes);
3171 // Print atomic ordering/alignment for memory operations
3172 if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3174 writeAtomic(LI->getOrdering(), LI->getSynchScope());
3175 if (LI->getAlignment())
3176 Out << ", align " << LI->getAlignment();
3177 } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
3179 writeAtomic(SI->getOrdering(), SI->getSynchScope());
3180 if (SI->getAlignment())
3181 Out << ", align " << SI->getAlignment();
3182 } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
3183 writeAtomicCmpXchg(CXI->getSuccessOrdering(), CXI->getFailureOrdering(),
3184 CXI->getSynchScope());
3185 } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
3186 writeAtomic(RMWI->getOrdering(), RMWI->getSynchScope());
3187 } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
3188 writeAtomic(FI->getOrdering(), FI->getSynchScope());
3191 // Print Metadata info.
3192 SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
3193 I.getAllMetadata(InstMD);
3194 printMetadataAttachments(InstMD, ", ");
3196 // Print a nice comment.
3197 printInfoComment(I);
3200 void AssemblyWriter::printMetadataAttachments(
3201 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
3202 StringRef Separator) {
3206 if (MDNames.empty())
3207 MDs[0].second->getContext().getMDKindNames(MDNames);
3209 for (const auto &I : MDs) {
3210 unsigned Kind = I.first;
3212 if (Kind < MDNames.size()) {
3214 printMetadataIdentifier(MDNames[Kind], Out);
3216 Out << "!<unknown kind #" << Kind << ">";
3218 WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
3222 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
3223 Out << '!' << Slot << " = ";
3224 printMDNodeBody(Node);
3228 void AssemblyWriter::writeAllMDNodes() {
3229 SmallVector<const MDNode *, 16> Nodes;
3230 Nodes.resize(Machine.mdn_size());
3231 for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
3233 Nodes[I->second] = cast<MDNode>(I->first);
3235 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
3236 writeMDNode(i, Nodes[i]);
3240 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
3241 WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
3244 void AssemblyWriter::writeAllAttributeGroups() {
3245 std::vector<std::pair<AttributeSet, unsigned> > asVec;
3246 asVec.resize(Machine.as_size());
3248 for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
3250 asVec[I->second] = *I;
3252 for (const auto &I : asVec)
3253 Out << "attributes #" << I.second << " = { "
3254 << I.first.getAsString(AttributeSet::FunctionIndex, true) << " }\n";
3257 void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
3258 bool IsInFunction = Machine.getFunction();
3262 Out << "uselistorder";
3263 if (const BasicBlock *BB =
3264 IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
3266 writeOperand(BB->getParent(), false);
3268 writeOperand(BB, false);
3271 writeOperand(Order.V, true);
3275 assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
3276 Out << Order.Shuffle[0];
3277 for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
3278 Out << ", " << Order.Shuffle[I];
3282 void AssemblyWriter::printUseLists(const Function *F) {
3284 [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
3289 Out << "\n; uselistorder directives\n";
3291 printUseListOrder(UseListOrders.back());
3292 UseListOrders.pop_back();
3296 //===----------------------------------------------------------------------===//
3297 // External Interface declarations
3298 //===----------------------------------------------------------------------===//
3300 void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
3301 bool ShouldPreserveUseListOrder,
3302 bool IsForDebug) const {
3303 SlotTracker SlotTable(this->getParent());
3304 formatted_raw_ostream OS(ROS);
3305 AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
3307 ShouldPreserveUseListOrder);
3308 W.printFunction(this);
3311 void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
3312 bool ShouldPreserveUseListOrder, bool IsForDebug) const {
3313 SlotTracker SlotTable(this);
3314 formatted_raw_ostream OS(ROS);
3315 AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
3316 ShouldPreserveUseListOrder);
3317 W.printModule(this);
3320 void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
3321 SlotTracker SlotTable(getParent());
3322 formatted_raw_ostream OS(ROS);
3323 AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
3324 W.printNamedMDNode(this);
3327 void NamedMDNode::print(raw_ostream &ROS, ModuleSlotTracker &MST,
3328 bool IsForDebug) const {
3329 Optional<SlotTracker> LocalST;
3330 SlotTracker *SlotTable;
3331 if (auto *ST = MST.getMachine())
3334 LocalST.emplace(getParent());
3335 SlotTable = &*LocalST;
3338 formatted_raw_ostream OS(ROS);
3339 AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
3340 W.printNamedMDNode(this);
3343 void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
3344 PrintLLVMName(ROS, getName(), ComdatPrefix);
3345 ROS << " = comdat ";
3347 switch (getSelectionKind()) {
3351 case Comdat::ExactMatch:
3352 ROS << "exactmatch";
3354 case Comdat::Largest:
3357 case Comdat::NoDuplicates:
3358 ROS << "noduplicates";
3360 case Comdat::SameSize:
3368 void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
3370 TP.print(const_cast<Type*>(this), OS);
3375 // If the type is a named struct type, print the body as well.
3376 if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
3377 if (!STy->isLiteral()) {
3379 TP.printStructBody(STy, OS);
3383 static bool isReferencingMDNode(const Instruction &I) {
3384 if (const auto *CI = dyn_cast<CallInst>(&I))
3385 if (Function *F = CI->getCalledFunction())
3386 if (F->isIntrinsic())
3387 for (auto &Op : I.operands())
3388 if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
3389 if (isa<MDNode>(V->getMetadata()))
3394 void Value::print(raw_ostream &ROS, bool IsForDebug) const {
3395 bool ShouldInitializeAllMetadata = false;
3396 if (auto *I = dyn_cast<Instruction>(this))
3397 ShouldInitializeAllMetadata = isReferencingMDNode(*I);
3398 else if (isa<Function>(this) || isa<MetadataAsValue>(this))
3399 ShouldInitializeAllMetadata = true;
3401 ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
3402 print(ROS, MST, IsForDebug);
3405 void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST,
3406 bool IsForDebug) const {
3407 formatted_raw_ostream OS(ROS);
3408 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
3409 SlotTracker &SlotTable =
3410 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
3411 auto incorporateFunction = [&](const Function *F) {
3413 MST.incorporateFunction(*F);
3416 if (const Instruction *I = dyn_cast<Instruction>(this)) {
3417 incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
3418 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
3419 W.printInstruction(*I);
3420 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
3421 incorporateFunction(BB->getParent());
3422 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
3423 W.printBasicBlock(BB);
3424 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
3425 AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
3426 if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
3428 else if (const Function *F = dyn_cast<Function>(GV))
3431 W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
3432 } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
3433 V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
3434 } else if (const Constant *C = dyn_cast<Constant>(this)) {
3435 TypePrinting TypePrinter;
3436 TypePrinter.print(C->getType(), OS);
3438 WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
3439 } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
3440 this->printAsOperand(OS, /* PrintType */ true, MST);
3442 llvm_unreachable("Unknown value to print out!");
3446 /// Print without a type, skipping the TypePrinting object.
3448 /// \return \c true iff printing was successful.
3449 static bool printWithoutType(const Value &V, raw_ostream &O,
3450 SlotTracker *Machine, const Module *M) {
3451 if (V.hasName() || isa<GlobalValue>(V) ||
3452 (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
3453 WriteAsOperandInternal(O, &V, nullptr, Machine, M);
3459 static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
3460 ModuleSlotTracker &MST) {
3461 TypePrinting TypePrinter;
3462 if (const Module *M = MST.getModule())
3463 TypePrinter.incorporateTypes(*M);
3465 TypePrinter.print(V.getType(), O);
3469 WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
3473 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3474 const Module *M) const {
3476 M = getModuleFromVal(this);
3479 if (printWithoutType(*this, O, nullptr, M))
3482 SlotTracker Machine(
3483 M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
3484 ModuleSlotTracker MST(Machine, M);
3485 printAsOperandImpl(*this, O, PrintType, MST);
3488 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3489 ModuleSlotTracker &MST) const {
3491 if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
3494 printAsOperandImpl(*this, O, PrintType, MST);
3497 static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
3498 ModuleSlotTracker &MST, const Module *M,
3499 bool OnlyAsOperand) {
3500 formatted_raw_ostream OS(ROS);
3502 TypePrinting TypePrinter;
3504 TypePrinter.incorporateTypes(*M);
3506 WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
3507 /* FromValue */ true);
3509 auto *N = dyn_cast<MDNode>(&MD);
3510 if (OnlyAsOperand || !N)
3514 WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
3517 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
3518 ModuleSlotTracker MST(M, isa<MDNode>(this));
3519 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3522 void Metadata::printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
3523 const Module *M) const {
3524 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3527 void Metadata::print(raw_ostream &OS, const Module *M,
3528 bool /*IsForDebug*/) const {
3529 ModuleSlotTracker MST(M, isa<MDNode>(this));
3530 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3533 void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
3534 const Module *M, bool /*IsForDebug*/) const {
3535 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3538 // Value::dump - allow easy printing of Values from the debugger.
3540 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3542 // Type::dump - allow easy printing of Types from the debugger.
3544 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3546 // Module::dump() - Allow printing of Modules from the debugger.
3548 void Module::dump() const {
3549 print(dbgs(), nullptr,
3550 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
3553 // \brief Allow printing of Comdats from the debugger.
3555 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3557 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
3559 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3562 void Metadata::dump() const { dump(nullptr); }
3565 void Metadata::dump(const Module *M) const {
3566 print(dbgs(), M, /*IsForDebug=*/true);