LCOV - code coverage report
Current view: top level - lib/IR - AsmWriter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1983 2023 98.0 %
Date: 2017-09-14 15:23:50 Functions: 136 136 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- AsmWriter.cpp - Printing LLVM as an assembly file ------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This library implements the functionality defined in llvm/IR/Writer.h
      11             : //
      12             : // Note that these routines must be extremely tolerant of various errors in the
      13             : // LLVM code, because it can be used for debugging transformations.
      14             : //
      15             : //===----------------------------------------------------------------------===//
      16             : 
      17             : #include "llvm/ADT/APFloat.h"
      18             : #include "llvm/ADT/APInt.h"
      19             : #include "llvm/ADT/ArrayRef.h"
      20             : #include "llvm/ADT/DenseMap.h"
      21             : #include "llvm/ADT/None.h"
      22             : #include "llvm/ADT/Optional.h"
      23             : #include "llvm/ADT/STLExtras.h"
      24             : #include "llvm/ADT/SetVector.h"
      25             : #include "llvm/ADT/SmallString.h"
      26             : #include "llvm/ADT/SmallVector.h"
      27             : #include "llvm/ADT/StringExtras.h"
      28             : #include "llvm/ADT/StringRef.h"
      29             : #include "llvm/ADT/iterator_range.h"
      30             : #include "llvm/BinaryFormat/Dwarf.h"
      31             : #include "llvm/IR/Argument.h"
      32             : #include "llvm/IR/AssemblyAnnotationWriter.h"
      33             : #include "llvm/IR/Attributes.h"
      34             : #include "llvm/IR/BasicBlock.h"
      35             : #include "llvm/IR/CFG.h"
      36             : #include "llvm/IR/CallSite.h"
      37             : #include "llvm/IR/CallingConv.h"
      38             : #include "llvm/IR/Comdat.h"
      39             : #include "llvm/IR/Constant.h"
      40             : #include "llvm/IR/Constants.h"
      41             : #include "llvm/IR/DebugInfoMetadata.h"
      42             : #include "llvm/IR/DerivedTypes.h"
      43             : #include "llvm/IR/Function.h"
      44             : #include "llvm/IR/GlobalAlias.h"
      45             : #include "llvm/IR/GlobalIFunc.h"
      46             : #include "llvm/IR/GlobalIndirectSymbol.h"
      47             : #include "llvm/IR/GlobalObject.h"
      48             : #include "llvm/IR/GlobalValue.h"
      49             : #include "llvm/IR/GlobalVariable.h"
      50             : #include "llvm/IR/IRPrintingPasses.h"
      51             : #include "llvm/IR/InlineAsm.h"
      52             : #include "llvm/IR/InstrTypes.h"
      53             : #include "llvm/IR/Instruction.h"
      54             : #include "llvm/IR/Instructions.h"
      55             : #include "llvm/IR/LLVMContext.h"
      56             : #include "llvm/IR/Metadata.h"
      57             : #include "llvm/IR/Module.h"
      58             : #include "llvm/IR/ModuleSlotTracker.h"
      59             : #include "llvm/IR/Operator.h"
      60             : #include "llvm/IR/Statepoint.h"
      61             : #include "llvm/IR/Type.h"
      62             : #include "llvm/IR/TypeFinder.h"
      63             : #include "llvm/IR/Use.h"
      64             : #include "llvm/IR/UseListOrder.h"
      65             : #include "llvm/IR/User.h"
      66             : #include "llvm/IR/Value.h"
      67             : #include "llvm/Support/AtomicOrdering.h"
      68             : #include "llvm/Support/Casting.h"
      69             : #include "llvm/Support/Compiler.h"
      70             : #include "llvm/Support/Debug.h"
      71             : #include "llvm/Support/ErrorHandling.h"
      72             : #include "llvm/Support/Format.h"
      73             : #include "llvm/Support/FormattedStream.h"
      74             : #include "llvm/Support/raw_ostream.h"
      75             : #include <algorithm>
      76             : #include <cassert>
      77             : #include <cctype>
      78             : #include <cstddef>
      79             : #include <cstdint>
      80             : #include <iterator>
      81             : #include <memory>
      82             : #include <string>
      83             : #include <tuple>
      84             : #include <utility>
      85             : #include <vector>
      86             : 
      87             : using namespace llvm;
      88             : 
      89             : // Make virtual table appear in this compilation unit.
      90             : AssemblyAnnotationWriter::~AssemblyAnnotationWriter() = default;
      91             : 
      92             : //===----------------------------------------------------------------------===//
      93             : // Helper Functions
      94             : //===----------------------------------------------------------------------===//
      95             : 
      96             : namespace {
      97             : 
      98        2968 : struct OrderMap {
      99             :   DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
     100             : 
     101             :   unsigned size() const { return IDs.size(); }
     102       33052 :   std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
     103             : 
     104             :   std::pair<unsigned, bool> lookup(const Value *V) const {
     105       35298 :     return IDs.lookup(V);
     106             :   }
     107             : 
     108             :   void index(const Value *V) {
     109             :     // Explicitly sequence get-size and insert-value operations to avoid UB.
     110       26524 :     unsigned ID = IDs.size() + 1;
     111       26524 :     IDs[V].first = ID;
     112             :   }
     113             : };
     114             : 
     115             : } // end anonymous namespace
     116             : 
     117       14640 : static void orderValue(const Value *V, OrderMap &OM) {
     118       14640 :   if (OM.lookup(V).first)
     119             :     return;
     120             : 
     121        5108 :   if (const Constant *C = dyn_cast<Constant>(V))
     122       10216 :     if (C->getNumOperands() && !isa<GlobalValue>(C))
     123        2384 :       for (const Value *Op : C->operands())
     124        2496 :         if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
     125         928 :           orderValue(Op, OM);
     126             : 
     127             :   // Note: we cannot cache this lookup above, since inserting into the map
     128             :   // changes the map's size, and thus affects the other IDs.
     129             :   OM.index(V);
     130             : }
     131             : 
     132         742 : static OrderMap orderModule(const Module *M) {
     133             :   // This needs to match the order used by ValueEnumerator::ValueEnumerator()
     134             :   // and ValueEnumerator::incorporateFunction().
     135         742 :   OrderMap OM;
     136             : 
     137        1636 :   for (const GlobalVariable &G : M->globals()) {
     138         894 :     if (G.hasInitializer())
     139         746 :       if (!isa<GlobalValue>(G.getInitializer()))
     140         670 :         orderValue(G.getInitializer(), OM);
     141         894 :     orderValue(&G, OM);
     142             :   }
     143         886 :   for (const GlobalAlias &A : M->aliases()) {
     144         144 :     if (!isa<GlobalValue>(A.getAliasee()))
     145          60 :       orderValue(A.getAliasee(), OM);
     146         144 :     orderValue(&A, OM);
     147             :   }
     148         754 :   for (const GlobalIFunc &I : M->ifuncs()) {
     149          12 :     if (!isa<GlobalValue>(I.getResolver()))
     150           0 :       orderValue(I.getResolver(), OM);
     151          12 :     orderValue(&I, OM);
     152             :   }
     153        4272 :   for (const Function &F : *M) {
     154        4128 :     for (const Use &U : F.operands())
     155          36 :       if (!isa<GlobalValue>(U.get()))
     156          36 :         orderValue(U.get(), OM);
     157             : 
     158        2046 :     orderValue(&F, OM);
     159             : 
     160        2046 :     if (F.isDeclaration())
     161         334 :       continue;
     162             : 
     163        3010 :     for (const Argument &A : F.args())
     164        1298 :       orderValue(&A, OM);
     165        7096 :     for (const BasicBlock &BB : F) {
     166        1960 :       orderValue(&BB, OM);
     167       10760 :       for (const Instruction &I : BB) {
     168       16296 :         for (const Value *Op : I.operands())
     169        7024 :           if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
     170        4840 :               isa<InlineAsm>(*Op))
     171        1712 :             orderValue(Op, OM);
     172        4880 :         orderValue(&I, OM);
     173             :       }
     174             :     }
     175             :   }
     176         742 :   return OM;
     177             : }
     178             : 
     179        1472 : static void predictValueUseListOrderImpl(const Value *V, const Function *F,
     180             :                                          unsigned ID, const OrderMap &OM,
     181             :                                          UseListOrderStack &Stack) {
     182             :   // Predict use-list order for this one.
     183             :   using Entry = std::pair<const Use *, unsigned>;
     184        2298 :   SmallVector<Entry, 64> List;
     185        9374 :   for (const Use &U : V->uses())
     186             :     // Check if this user will be serialized.
     187        9916 :     if (OM.lookup(U.getUser()).first)
     188       14502 :       List.push_back(std::make_pair(&U, List.size()));
     189             : 
     190        1472 :   if (List.size() < 2)
     191             :     // We may have lost some users.
     192         646 :     return;
     193             : 
     194             :   bool GetsReversed =
     195        5422 :       !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
     196        1436 :   if (auto *BA = dyn_cast<BlockAddress>(V))
     197          64 :     ID = OM.lookup(BA->getBasicBlock()).first;
     198       13450 :   std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) {
     199        7834 :     const Use *LU = L.first;
     200        7834 :     const Use *RU = R.first;
     201        7834 :     if (LU == RU)
     202             :       return false;
     203             : 
     204       15668 :     auto LID = OM.lookup(LU->getUser()).first;
     205       15668 :     auto RID = OM.lookup(RU->getUser()).first;
     206             : 
     207             :     // If ID is 4, then expect: 7 6 5 1 2 3.
     208        7834 :     if (LID < RID) {
     209        7834 :       if (GetsReversed)
     210        7276 :         if (RID <= ID)
     211             :           return true;
     212             :       return false;
     213             :     }
     214        3951 :     if (RID < LID) {
     215        3109 :       if (GetsReversed)
     216        2922 :         if (LID <= ID)
     217             :           return false;
     218             :       return true;
     219             :     }
     220             : 
     221             :     // LID and RID are equal, so we have different operands of the same user.
     222             :     // Assume operands are added in order for all instructions.
     223         842 :     if (GetsReversed)
     224         803 :       if (LID <= ID)
     225          12 :         return LU->getOperandNo() < RU->getOperandNo();
     226         830 :     return LU->getOperandNo() > RU->getOperandNo();
     227             :   });
     228             : 
     229        4212 :   if (std::is_sorted(
     230             :           List.begin(), List.end(),
     231             :           [](const Entry &L, const Entry &R) { return L.second < R.second; }))
     232             :     // Order is already correct.
     233             :     return;
     234             : 
     235             :   // Store the shuffle.
     236         826 :   Stack.emplace_back(V, F, List.size());
     237             :   assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
     238        4770 :   for (size_t I = 0, E = List.size(); I != E; ++I)
     239        9354 :     Stack.back().Shuffle[I] = List[I].second;
     240             : }
     241             : 
     242       16526 : static void predictValueUseListOrder(const Value *V, const Function *F,
     243             :                                      OrderMap &OM, UseListOrderStack &Stack) {
     244       16526 :   auto &IDPair = OM[V];
     245             :   assert(IDPair.first && "Unmapped value");
     246       16526 :   if (IDPair.second)
     247             :     // Already predicted.
     248             :     return;
     249             : 
     250             :   // Do the actual prediction.
     251       13262 :   IDPair.second = true;
     252       37188 :   if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())
     253        1472 :     predictValueUseListOrderImpl(V, F, IDPair.first, OM, Stack);
     254             : 
     255             :   // Recursive descent into constants.
     256        5108 :   if (const Constant *C = dyn_cast<Constant>(V))
     257       10216 :     if (C->getNumOperands()) // Visit GlobalValues.
     258        5150 :       for (const Value *Op : C->operands())
     259        2186 :         if (isa<Constant>(Op)) // Visit GlobalValues.
     260        2154 :           predictValueUseListOrder(Op, F, OM, Stack);
     261             : }
     262             : 
     263         742 : static UseListOrderStack predictUseListOrder(const Module *M) {
     264        1484 :   OrderMap OM = orderModule(M);
     265             : 
     266             :   // Use-list orders need to be serialized after all the users have been added
     267             :   // to a value, or else the shuffles will be incomplete.  Store them per
     268             :   // function in a stack.
     269             :   //
     270             :   // Aside from function order, the order of values doesn't matter much here.
     271         742 :   UseListOrderStack Stack;
     272             : 
     273             :   // We want to visit the functions backward now so we can list function-local
     274             :   // constants in the last Function they're used in.  Module-level constants
     275             :   // have already been visited above.
     276        4272 :   for (const Function &F : make_range(M->rbegin(), M->rend())) {
     277        2046 :     if (F.isDeclaration())
     278         334 :       continue;
     279        7096 :     for (const BasicBlock &BB : F)
     280        1960 :       predictValueUseListOrder(&BB, &F, OM, Stack);
     281        3010 :     for (const Argument &A : F.args())
     282        1298 :       predictValueUseListOrder(&A, &F, OM, Stack);
     283        7096 :     for (const BasicBlock &BB : F)
     284       10760 :       for (const Instruction &I : BB)
     285       16296 :         for (const Value *Op : I.operands())
     286        4352 :           if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
     287        2200 :             predictValueUseListOrder(Op, &F, OM, Stack);
     288        7096 :     for (const BasicBlock &BB : F)
     289       10760 :       for (const Instruction &I : BB)
     290        4880 :         predictValueUseListOrder(&I, &F, OM, Stack);
     291             :   }
     292             : 
     293             :   // Visit globals last.
     294        1636 :   for (const GlobalVariable &G : M->globals())
     295         894 :     predictValueUseListOrder(&G, nullptr, OM, Stack);
     296        4272 :   for (const Function &F : *M)
     297        2046 :     predictValueUseListOrder(&F, nullptr, OM, Stack);
     298         886 :   for (const GlobalAlias &A : M->aliases())
     299         144 :     predictValueUseListOrder(&A, nullptr, OM, Stack);
     300         754 :   for (const GlobalIFunc &I : M->ifuncs())
     301          12 :     predictValueUseListOrder(&I, nullptr, OM, Stack);
     302        1636 :   for (const GlobalVariable &G : M->globals())
     303         894 :     if (G.hasInitializer())
     304         746 :       predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
     305         886 :   for (const GlobalAlias &A : M->aliases())
     306         144 :     predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
     307         754 :   for (const GlobalIFunc &I : M->ifuncs())
     308          12 :     predictValueUseListOrder(I.getResolver(), nullptr, OM, Stack);
     309        4272 :   for (const Function &F : *M)
     310        4128 :     for (const Use &U : F.operands())
     311          36 :       predictValueUseListOrder(U.get(), nullptr, OM, Stack);
     312             : 
     313         742 :   return Stack;
     314             : }
     315             : 
     316       74449 : static const Module *getModuleFromVal(const Value *V) {
     317        4219 :   if (const Argument *MA = dyn_cast<Argument>(V))
     318        4219 :     return MA->getParent() ? MA->getParent()->getParent() : nullptr;
     319             : 
     320        9677 :   if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
     321        9677 :     return BB->getParent() ? BB->getParent()->getParent() : nullptr;
     322             : 
     323       50795 :   if (const Instruction *I = dyn_cast<Instruction>(V)) {
     324       50795 :     const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
     325       50719 :     return M ? M->getParent() : nullptr;
     326             :   }
     327             : 
     328         987 :   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
     329         987 :     return GV->getParent();
     330             : 
     331          10 :   if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
     332          40 :     for (const User *U : MAV->users())
     333          20 :       if (isa<Instruction>(U))
     334          10 :         if (const Module *M = getModuleFromVal(U))
     335             :           return M;
     336             :     return nullptr;
     337             :   }
     338             : 
     339             :   return nullptr;
     340             : }
     341             : 
     342       12877 : static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
     343       12877 :   switch (cc) {
     344          59 :   default:                         Out << "cc" << cc; break;
     345         357 :   case CallingConv::Fast:          Out << "fastcc"; break;
     346         243 :   case CallingConv::Cold:          Out << "coldcc"; break;
     347           7 :   case CallingConv::WebKit_JS:     Out << "webkit_jscc"; break;
     348           7 :   case CallingConv::AnyReg:        Out << "anyregcc"; break;
     349           9 :   case CallingConv::PreserveMost:  Out << "preserve_mostcc"; break;
     350           9 :   case CallingConv::PreserveAll:   Out << "preserve_allcc"; break;
     351          50 :   case CallingConv::CXX_FAST_TLS:  Out << "cxx_fast_tlscc"; break;
     352          40 :   case CallingConv::GHC:           Out << "ghccc"; break;
     353         139 :   case CallingConv::X86_StdCall:   Out << "x86_stdcallcc"; break;
     354         121 :   case CallingConv::X86_FastCall:  Out << "x86_fastcallcc"; break;
     355        5880 :   case CallingConv::X86_ThisCall:  Out << "x86_thiscallcc"; break;
     356         148 :   case CallingConv::X86_RegCall:   Out << "x86_regcallcc"; break;
     357         117 :   case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
     358          28 :   case CallingConv::Intel_OCL_BI:  Out << "intel_ocl_bicc"; break;
     359          30 :   case CallingConv::ARM_APCS:      Out << "arm_apcscc"; break;
     360         582 :   case CallingConv::ARM_AAPCS:     Out << "arm_aapcscc"; break;
     361         630 :   case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
     362          24 :   case CallingConv::MSP430_INTR:   Out << "msp430_intrcc"; break;
     363           9 :   case CallingConv::AVR_INTR:      Out << "avr_intrcc "; break;
     364           9 :   case CallingConv::AVR_SIGNAL:    Out << "avr_signalcc "; break;
     365          24 :   case CallingConv::PTX_Kernel:    Out << "ptx_kernel"; break;
     366          96 :   case CallingConv::PTX_Device:    Out << "ptx_device"; break;
     367          17 :   case CallingConv::X86_64_SysV:   Out << "x86_64_sysvcc"; break;
     368          29 :   case CallingConv::Win64:         Out << "win64cc"; break;
     369         254 :   case CallingConv::SPIR_FUNC:     Out << "spir_func"; break;
     370         163 :   case CallingConv::SPIR_KERNEL:   Out << "spir_kernel"; break;
     371        2181 :   case CallingConv::Swift:         Out << "swiftcc"; break;
     372          33 :   case CallingConv::X86_INTR:      Out << "x86_intrcc"; break;
     373          10 :   case CallingConv::HHVM:          Out << "hhvmcc"; break;
     374          12 :   case CallingConv::HHVM_C:        Out << "hhvm_ccc"; break;
     375          21 :   case CallingConv::AMDGPU_VS:     Out << "amdgpu_vs"; break;
     376           4 :   case CallingConv::AMDGPU_HS:     Out << "amdgpu_hs"; break;
     377           8 :   case CallingConv::AMDGPU_GS:     Out << "amdgpu_gs"; break;
     378         133 :   case CallingConv::AMDGPU_PS:     Out << "amdgpu_ps"; break;
     379           8 :   case CallingConv::AMDGPU_CS:     Out << "amdgpu_cs"; break;
     380        1386 :   case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
     381             :   }
     382       12877 : }
     383             : 
     384      296152 : void llvm::PrintEscapedString(StringRef Name, raw_ostream &Out) {
     385     5897069 :   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
     386    10609530 :     unsigned char C = Name[i];
     387     5304765 :     if (isprint(C) && C != '\\' && C != '"')
     388     5242818 :       Out << C;
     389             :     else
     390      247788 :       Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
     391             :   }
     392      296152 : }
     393             : 
     394             : enum PrefixType {
     395             :   GlobalPrefix,
     396             :   ComdatPrefix,
     397             :   LabelPrefix,
     398             :   LocalPrefix,
     399             :   NoPrefix
     400             : };
     401             : 
     402     2710716 : void llvm::printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name) {
     403             :   assert(!Name.empty() && "Cannot get empty name!");
     404             : 
     405             :   // Scan the name to see if it needs quotes first.
     406     5421432 :   bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
     407             :   if (!NeedsQuotes) {
     408    33252825 :     for (unsigned i = 0, e = Name.size(); i != e; ++i) {
     409             :       // By making this unsigned, the value passed in to isalnum will always be
     410             :       // in the range 0-255.  This is important when building with MSVC because
     411             :       // its implementation will assert.  This situation can arise when dealing
     412             :       // with UTF-8 multibyte characters.
     413    55862820 :       unsigned char C = Name[i];
     414    27931410 :       if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
     415             :           C != '_') {
     416             :         NeedsQuotes = true;
     417             :         break;
     418             :       }
     419             :     }
     420             :   }
     421             : 
     422             :   // If we didn't need any quotes, just write out the name in one blast.
     423     2710716 :   if (!NeedsQuotes) {
     424     2611539 :     OS << Name;
     425     2611539 :     return;
     426             :   }
     427             : 
     428             :   // Okay, we need quotes.  Output the quotes and escape any scary characters as
     429             :   // needed.
     430       99177 :   OS << '"';
     431       99177 :   PrintEscapedString(Name, OS);
     432             :   OS << '"';
     433             : }
     434             : 
     435             : /// Turn the specified name into an 'LLVM name', which is either prefixed with %
     436             : /// (if the string only contains simple characters) or is surrounded with ""'s
     437             : /// (if it has special chars in it). Print it out.
     438     2657188 : static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
     439     2657188 :   switch (Prefix) {
     440             :   case NoPrefix:
     441             :     break;
     442      586887 :   case GlobalPrefix:
     443             :     OS << '@';
     444             :     break;
     445       14882 :   case ComdatPrefix:
     446             :     OS << '$';
     447             :     break;
     448             :   case LabelPrefix:
     449             :     break;
     450     2055419 :   case LocalPrefix:
     451             :     OS << '%';
     452             :     break;
     453             :   }
     454     2710113 :   printLLVMNameWithoutPrefix(OS, Name);
     455     2657188 : }
     456             : 
     457             : /// Turn the specified name into an 'LLVM name', which is either prefixed with %
     458             : /// (if the string only contains simple characters) or is surrounded with ""'s
     459             : /// (if it has special chars in it). Print it out.
     460     2268848 : static void PrintLLVMName(raw_ostream &OS, const Value *V) {
     461     2268848 :   PrintLLVMName(OS, V->getName(),
     462     2268848 :                 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
     463     2268848 : }
     464             : 
     465             : namespace {
     466             : 
     467      163664 : class TypePrinting {
     468             : public:
     469             :   /// NamedTypes - The named types that are used by the current module.
     470             :   TypeFinder NamedTypes;
     471             : 
     472             :   /// NumberedTypes - The numbered types, along with their value.
     473             :   DenseMap<StructType*, unsigned> NumberedTypes;
     474             : 
     475      163664 :   TypePrinting() = default;
     476             :   TypePrinting(const TypePrinting &) = delete;
     477             :   TypePrinting &operator=(const TypePrinting &) = delete;
     478             : 
     479             :   void incorporateTypes(const Module &M);
     480             : 
     481             :   void print(Type *Ty, raw_ostream &OS);
     482             : 
     483             :   void printStructBody(StructType *Ty, raw_ostream &OS);
     484             : };
     485             : 
     486             : } // end anonymous namespace
     487             : 
     488       48846 : void TypePrinting::incorporateTypes(const Module &M) {
     489       48846 :   NamedTypes.run(M, false);
     490             : 
     491             :   // The list of struct types we got back includes all the struct types, split
     492             :   // the unnamed ones out to a numbering and remove the anonymous structs.
     493       48846 :   unsigned NextNumber = 0;
     494             : 
     495       97692 :   std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
     496      246319 :   for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
     497       50935 :     StructType *STy = *I;
     498             : 
     499             :     // Ignore anonymous types.
     500      101870 :     if (STy->isLiteral())
     501        8739 :       continue;
     502             : 
     503       84392 :     if (STy->getName().empty())
     504        1816 :       NumberedTypes[STy] = NextNumber++;
     505             :     else
     506       82576 :       *NextToUse++ = STy;
     507             :   }
     508             : 
     509      146538 :   NamedTypes.erase(NextToUse, NamedTypes.end());
     510       48846 : }
     511             : 
     512             : 
     513             : /// CalcTypeName - Write the specified type to the specified raw_ostream, making
     514             : /// use of type names or up references to shorten the type name where possible.
     515     6728529 : void TypePrinting::print(Type *Ty, raw_ostream &OS) {
     516     6728529 :   switch (Ty->getTypeID()) {
     517      165630 :   case Type::VoidTyID:      OS << "void"; return;
     518       10043 :   case Type::HalfTyID:      OS << "half"; return;
     519      196873 :   case Type::FloatTyID:     OS << "float"; return;
     520      149994 :   case Type::DoubleTyID:    OS << "double"; return;
     521        6830 :   case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
     522        2511 :   case Type::FP128TyID:     OS << "fp128"; return;
     523         982 :   case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
     524      113048 :   case Type::LabelTyID:     OS << "label"; return;
     525       12012 :   case Type::MetadataTyID:  OS << "metadata"; return;
     526        2844 :   case Type::X86_MMXTyID:   OS << "x86_mmx"; return;
     527        1575 :   case Type::TokenTyID:     OS << "token"; return;
     528     2832499 :   case Type::IntegerTyID:
     529     8497497 :     OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
     530             :     return;
     531             : 
     532       58130 :   case Type::FunctionTyID: {
     533       58130 :     FunctionType *FTy = cast<FunctionType>(Ty);
     534       58130 :     print(FTy->getReturnType(), OS);
     535       58130 :     OS << " (";
     536      123402 :     for (FunctionType::param_iterator I = FTy->param_begin(),
     537       58130 :          E = FTy->param_end(); I != E; ++I) {
     538       65272 :       if (I != FTy->param_begin())
     539       29460 :         OS << ", ";
     540       65272 :       print(*I, OS);
     541             :     }
     542       58130 :     if (FTy->isVarArg()) {
     543       22639 :       if (FTy->getNumParams()) OS << ", ";
     544       22639 :       OS << "...";
     545             :     }
     546             :     OS << ')';
     547             :     return;
     548             :   }
     549      454906 :   case Type::StructTyID: {
     550      454906 :     StructType *STy = cast<StructType>(Ty);
     551             : 
     552      454906 :     if (STy->isLiteral())
     553       82954 :       return printStructBody(STy, OS);
     554             : 
     555      743904 :     if (!STy->getName().empty())
     556      352351 :       return PrintLLVMName(OS, STy->getName(), LocalPrefix);
     557             : 
     558       19601 :     DenseMap<StructType*, unsigned>::iterator I = NumberedTypes.find(STy);
     559       58803 :     if (I != NumberedTypes.end())
     560       19591 :       OS << '%' << I->second;
     561             :     else  // Not enumerated, print the hex address.
     562          10 :       OS << "%\"type " << STy << '\"';
     563             :     return;
     564             :   }
     565     1680684 :   case Type::PointerTyID: {
     566     1680684 :     PointerType *PTy = cast<PointerType>(Ty);
     567     1680684 :     print(PTy->getElementType(), OS);
     568     1680684 :     if (unsigned AddressSpace = PTy->getAddressSpace())
     569       40998 :       OS << " addrspace(" << AddressSpace << ')';
     570             :     OS << '*';
     571             :     return;
     572             :   }
     573      186045 :   case Type::ArrayTyID: {
     574      186045 :     ArrayType *ATy = cast<ArrayType>(Ty);
     575      186045 :     OS << '[' << ATy->getNumElements() << " x ";
     576      186045 :     print(ATy->getElementType(), OS);
     577             :     OS << ']';
     578             :     return;
     579             :   }
     580      853923 :   case Type::VectorTyID: {
     581      853923 :     VectorType *PTy = cast<VectorType>(Ty);
     582      853923 :     OS << "<" << PTy->getNumElements() << " x ";
     583      853923 :     print(PTy->getElementType(), OS);
     584             :     OS << '>';
     585             :     return;
     586             :   }
     587             :   }
     588           0 :   llvm_unreachable("Invalid TypeID");
     589             : }
     590             : 
     591      105042 : void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
     592      105042 :   if (STy->isOpaque()) {
     593        1603 :     OS << "opaque";
     594        1603 :     return;
     595             :   }
     596             : 
     597      103439 :   if (STy->isPacked())
     598             :     OS << '<';
     599             : 
     600      103439 :   if (STy->getNumElements() == 0) {
     601         426 :     OS << "{}";
     602             :   } else {
     603      103013 :     StructType::element_iterator I = STy->element_begin();
     604      103013 :     OS << "{ ";
     605      103013 :     print(*I++, OS);
     606      478366 :     for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
     607      272340 :       OS << ", ";
     608      272340 :       print(*I, OS);
     609             :     }
     610             : 
     611      103013 :     OS << " }";
     612             :   }
     613      103439 :   if (STy->isPacked())
     614             :     OS << '>';
     615             : }
     616             : 
     617             : namespace llvm {
     618             : 
     619             : //===----------------------------------------------------------------------===//
     620             : // SlotTracker Class: Enumerate slot numbers for unnamed values
     621             : //===----------------------------------------------------------------------===//
     622             : /// This class provides computation of slot numbers for LLVM Assembly writing.
     623             : ///
     624      437010 : class SlotTracker {
     625             : public:
     626             :   /// ValueMap - A mapping of Values to slot numbers.
     627             :   using ValueMap = DenseMap<const Value *, unsigned>;
     628             : 
     629             : private:
     630             :   /// TheModule - The module for which we are holding slot numbers.
     631             :   const Module* TheModule;
     632             : 
     633             :   /// TheFunction - The function for which we are holding slot numbers.
     634             :   const Function* TheFunction = nullptr;
     635             :   bool FunctionProcessed = false;
     636             :   bool ShouldInitializeAllMetadata;
     637             : 
     638             :   /// mMap - The slot map for the module level data.
     639             :   ValueMap mMap;
     640             :   unsigned mNext = 0;
     641             : 
     642             :   /// fMap - The slot map for the function level data.
     643             :   ValueMap fMap;
     644             :   unsigned fNext = 0;
     645             : 
     646             :   /// mdnMap - Map for MDNodes.
     647             :   DenseMap<const MDNode*, unsigned> mdnMap;
     648             :   unsigned mdnNext = 0;
     649             : 
     650             :   /// asMap - The slot map for attribute sets.
     651             :   DenseMap<AttributeSet, unsigned> asMap;
     652             :   unsigned asNext = 0;
     653             : 
     654             : public:
     655             :   /// Construct from a module.
     656             :   ///
     657             :   /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
     658             :   /// functions, giving correct numbering for metadata referenced only from
     659             :   /// within a function (even if no functions have been initialized).
     660             :   explicit SlotTracker(const Module *M,
     661             :                        bool ShouldInitializeAllMetadata = false);
     662             : 
     663             :   /// Construct from a function, starting out in incorp state.
     664             :   ///
     665             :   /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
     666             :   /// functions, giving correct numbering for metadata referenced only from
     667             :   /// within a function (even if no functions have been initialized).
     668             :   explicit SlotTracker(const Function *F,
     669             :                        bool ShouldInitializeAllMetadata = false);
     670             : 
     671             :   SlotTracker(const SlotTracker &) = delete;
     672             :   SlotTracker &operator=(const SlotTracker &) = delete;
     673             : 
     674             :   /// Return the slot number of the specified value in it's type
     675             :   /// plane.  If something is not in the SlotTracker, return -1.
     676             :   int getLocalSlot(const Value *V);
     677             :   int getGlobalSlot(const GlobalValue *V);
     678             :   int getMetadataSlot(const MDNode *N);
     679             :   int getAttributeGroupSlot(AttributeSet AS);
     680             : 
     681             :   /// If you'd like to deal with a function instead of just a module, use
     682             :   /// this method to get its data into the SlotTracker.
     683             :   void incorporateFunction(const Function *F) {
     684      174362 :     TheFunction = F;
     685      174362 :     FunctionProcessed = false;
     686             :   }
     687             : 
     688             :   const Function *getFunction() const { return TheFunction; }
     689             : 
     690             :   /// After calling incorporateFunction, use this method to remove the
     691             :   /// most recently incorporated function from the SlotTracker. This
     692             :   /// will reset the state of the machine back to just the module contents.
     693             :   void purgeFunction();
     694             : 
     695             :   /// MDNode map iterators.
     696             :   using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;
     697             : 
     698        6918 :   mdn_iterator mdn_begin() { return mdnMap.begin(); }
     699       13836 :   mdn_iterator mdn_end() { return mdnMap.end(); }
     700       13836 :   unsigned mdn_size() const { return mdnMap.size(); }
     701       24804 :   bool mdn_empty() const { return mdnMap.empty(); }
     702             : 
     703             :   /// AttributeSet map iterators.
     704             :   using as_iterator = DenseMap<AttributeSet, unsigned>::iterator;
     705             : 
     706        8178 :   as_iterator as_begin()   { return asMap.begin(); }
     707       16356 :   as_iterator as_end()     { return asMap.end(); }
     708       16356 :   unsigned as_size() const { return asMap.size(); }
     709       24804 :   bool as_empty() const    { return asMap.empty(); }
     710             : 
     711             :   /// This function does the actual initialization.
     712             :   inline void initialize();
     713             : 
     714             :   // Implementation Details
     715             : private:
     716             :   /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
     717             :   void CreateModuleSlot(const GlobalValue *V);
     718             : 
     719             :   /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
     720             :   void CreateMetadataSlot(const MDNode *N);
     721             : 
     722             :   /// CreateFunctionSlot - Insert the specified Value* into the slot table.
     723             :   void CreateFunctionSlot(const Value *V);
     724             : 
     725             :   /// \brief Insert the specified AttributeSet into the slot table.
     726             :   void CreateAttributeSetSlot(AttributeSet AS);
     727             : 
     728             :   /// Add all of the module level global variables (and their initializers)
     729             :   /// and function declarations, but not the contents of those functions.
     730             :   void processModule();
     731             : 
     732             :   /// Add all of the functions arguments, basic blocks, and instructions.
     733             :   void processFunction();
     734             : 
     735             :   /// Add the metadata directly attached to a GlobalObject.
     736             :   void processGlobalObjectMetadata(const GlobalObject &GO);
     737             : 
     738             :   /// Add all of the metadata from a function.
     739             :   void processFunctionMetadata(const Function &F);
     740             : 
     741             :   /// Add all of the metadata from an instruction.
     742             :   void processInstructionMetadata(const Instruction &I);
     743             : };
     744             : 
     745             : } // end namespace llvm
     746             : 
     747       19230 : ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
     748       19230 :                                      const Function *F)
     749       38460 :     : M(M), F(F), Machine(&Machine) {}
     750             : 
     751      106012 : ModuleSlotTracker::ModuleSlotTracker(const Module *M,
     752      106012 :                                      bool ShouldInitializeAllMetadata)
     753             :     : ShouldCreateStorage(M),
     754      212024 :       ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
     755             : 
     756             : ModuleSlotTracker::~ModuleSlotTracker() = default;
     757             : 
     758      119130 : SlotTracker *ModuleSlotTracker::getMachine() {
     759      119130 :   if (!ShouldCreateStorage)
     760       89784 :     return Machine;
     761             : 
     762       29346 :   ShouldCreateStorage = false;
     763       29346 :   MachineStorage =
     764       88038 :       llvm::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
     765       58692 :   Machine = MachineStorage.get();
     766       29346 :   return Machine;
     767             : }
     768             : 
     769       29040 : void ModuleSlotTracker::incorporateFunction(const Function &F) {
     770             :   // Using getMachine() may lazily create the slot tracker.
     771       29040 :   if (!getMachine())
     772             :     return;
     773             : 
     774             :   // Nothing to do if this is the right function already.
     775       29040 :   if (this->F == &F)
     776             :     return;
     777       28936 :   if (this->F)
     778          54 :     Machine->purgeFunction();
     779       57872 :   Machine->incorporateFunction(&F);
     780       28936 :   this->F = &F;
     781             : }
     782             : 
     783        1821 : int ModuleSlotTracker::getLocalSlot(const Value *V) {
     784             :   assert(F && "No function incorporated");
     785        1821 :   return Machine->getLocalSlot(V);
     786             : }
     787             : 
     788        1410 : static SlotTracker *createSlotTracker(const Value *V) {
     789          16 :   if (const Argument *FA = dyn_cast<Argument>(V))
     790          16 :     return new SlotTracker(FA->getParent());
     791             : 
     792        1162 :   if (const Instruction *I = dyn_cast<Instruction>(V))
     793        1162 :     if (I->getParent())
     794        1162 :       return new SlotTracker(I->getParent()->getParent());
     795             : 
     796         212 :   if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
     797         212 :     return new SlotTracker(BB->getParent());
     798             : 
     799          14 :   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
     800          14 :     return new SlotTracker(GV->getParent());
     801             : 
     802           0 :   if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
     803           0 :     return new SlotTracker(GA->getParent());
     804             : 
     805           0 :   if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
     806           0 :     return new SlotTracker(GIF->getParent());
     807             : 
     808           6 :   if (const Function *Func = dyn_cast<Function>(V))
     809           6 :     return new SlotTracker(Func);
     810             : 
     811             :   return nullptr;
     812             : }
     813             : 
     814             : #if 0
     815             : #define ST_DEBUG(X) dbgs() << X
     816             : #else
     817             : #define ST_DEBUG(X)
     818             : #endif
     819             : 
     820             : // Module level constructor. Causes the contents of the Module (sans functions)
     821             : // to be added to the slot table.
     822       86006 : SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
     823      430030 :     : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
     824             : 
     825             : // Function level constructor. Causes the contents of the Module and the one
     826             : // function provided to be added to the slot table.
     827        1396 : SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
     828        1396 :     : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
     829        6980 :       ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
     830             : 
     831     1396382 : inline void SlotTracker::initialize() {
     832     1396382 :   if (TheModule) {
     833       20287 :     processModule();
     834       20287 :     TheModule = nullptr; ///< Prevent re-processing next time we're called.
     835             :   }
     836             : 
     837     1396382 :   if (TheFunction && !FunctionProcessed)
     838      116465 :     processFunction();
     839     1396382 : }
     840             : 
     841             : // Iterate through all the global variables, functions, and global
     842             : // variable initializers and create slots for them.
     843       20287 : void SlotTracker::processModule() {
     844             :   ST_DEBUG("begin processModule!\n");
     845             : 
     846             :   // Add all of the unnamed global variables to the value table.
     847       97177 :   for (const GlobalVariable &Var : TheModule->globals()) {
     848      113206 :     if (!Var.hasName())
     849        3313 :       CreateModuleSlot(&Var);
     850       56603 :     processGlobalObjectMetadata(Var);
     851       56603 :     auto Attrs = Var.getAttributes();
     852       56603 :     if (Attrs.hasAttributes())
     853          33 :       CreateAttributeSetSlot(Attrs);
     854             :   }
     855             : 
     856       41628 :   for (const GlobalAlias &A : TheModule->aliases()) {
     857        2108 :     if (!A.hasName())
     858           4 :       CreateModuleSlot(&A);
     859             :   }
     860             : 
     861       40617 :   for (const GlobalIFunc &I : TheModule->ifuncs()) {
     862          86 :     if (!I.hasName())
     863           0 :       CreateModuleSlot(&I);
     864             :   }
     865             : 
     866             :   // Add metadata used by named metadata.
     867       53740 :   for (const NamedMDNode &NMD : TheModule->named_metadata()) {
     868       34631 :     for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
     869       21465 :       CreateMetadataSlot(NMD.getOperand(i));
     870             :   }
     871             : 
     872      307114 :   for (const Function &F : *TheModule) {
     873      492506 :     if (!F.hasName())
     874             :       // Add all the unnamed functions to the table.
     875          35 :       CreateModuleSlot(&F);
     876             : 
     877      246253 :     if (ShouldInitializeAllMetadata)
     878       29774 :       processFunctionMetadata(F);
     879             : 
     880             :     // Add all the function attributes to the table.
     881             :     // FIXME: Add attributes of other objects?
     882      246253 :     AttributeSet FnAttrs = F.getAttributes().getFnAttributes();
     883      246253 :     if (FnAttrs.hasAttributes())
     884      170821 :       CreateAttributeSetSlot(FnAttrs);
     885             :   }
     886             : 
     887             :   ST_DEBUG("end processModule!\n");
     888       20287 : }
     889             : 
     890             : // Process the arguments, basic blocks, and instructions  of a function.
     891      116465 : void SlotTracker::processFunction() {
     892             :   ST_DEBUG("begin processFunction!\n");
     893      116465 :   fNext = 0;
     894             : 
     895             :   // Process function metadata if it wasn't hit at the module-level.
     896      116465 :   if (!ShouldInitializeAllMetadata)
     897      114839 :     processFunctionMetadata(*TheFunction);
     898             : 
     899             :   // Add all the function arguments with no names.
     900      414445 :   for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
     901      232930 :       AE = TheFunction->arg_end(); AI != AE; ++AI)
     902      363030 :     if (!AI->hasName())
     903       66052 :       CreateFunctionSlot(&*AI);
     904             : 
     905             :   ST_DEBUG("Inserting Instructions:\n");
     906             : 
     907             :   // Add all of the basic blocks and instructions with no names.
     908      529918 :   for (auto &BB : *TheFunction) {
     909      361046 :     if (!BB.hasName())
     910      117189 :       CreateFunctionSlot(&BB);
     911             : 
     912     1951569 :     for (auto &I : BB) {
     913     3748413 :       if (!I.getType()->isVoidTy() && !I.hasName())
     914      478013 :         CreateFunctionSlot(&I);
     915             : 
     916             :       // We allow direct calls to any llvm.foo function here, because the
     917             :       // target may not be linked into the optimizer.
     918     2820000 :       if (auto CS = ImmutableCallSite(&I)) {
     919             :         // Add all the call attributes to the table.
     920      110282 :         AttributeSet Attrs = CS.getAttributes().getFnAttributes();
     921      110282 :         if (Attrs.hasAttributes())
     922       38634 :           CreateAttributeSetSlot(Attrs);
     923             :       }
     924             :     }
     925             :   }
     926             : 
     927      116465 :   FunctionProcessed = true;
     928             : 
     929             :   ST_DEBUG("end processFunction!\n");
     930      116465 : }
     931             : 
     932      201216 : void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
     933      402432 :   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
     934      201216 :   GO.getAllMetadata(MDs);
     935      608530 :   for (auto &MD : MDs)
     936        4882 :     CreateMetadataSlot(MD.second);
     937      201216 : }
     938             : 
     939      144613 : void SlotTracker::processFunctionMetadata(const Function &F) {
     940      144613 :   processGlobalObjectMetadata(F);
     941      642286 :   for (auto &BB : F) {
     942     2095759 :     for (auto &I : BB)
     943     1470418 :       processInstructionMetadata(I);
     944             :   }
     945      144613 : }
     946             : 
     947     1470418 : void SlotTracker::processInstructionMetadata(const Instruction &I) {
     948             :   // Process metadata used directly by intrinsics.
     949      112247 :   if (const CallInst *CI = dyn_cast<CallInst>(&I))
     950      107855 :     if (Function *F = CI->getCalledFunction())
     951      107855 :       if (F->isIntrinsic())
     952      287042 :         for (auto &Op : I.operands())
     953       10912 :           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
     954       18112 :             if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
     955        7200 :               CreateMetadataSlot(N);
     956             : 
     957             :   // Process metadata attached to this instruction.
     958     2940836 :   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
     959     1470418 :   I.getAllMetadata(MDs);
     960     4513197 :   for (auto &MD : MDs)
     961      101943 :     CreateMetadataSlot(MD.second);
     962     1470418 : }
     963             : 
     964             : /// Clean up after incorporating a function. This is the only way to get out of
     965             : /// the function incorporation state that affects get*Slot/Create*Slot. Function
     966             : /// incorporation state is indicated by TheFunction != 0.
     967      145480 : void SlotTracker::purgeFunction() {
     968             :   ST_DEBUG("begin purgeFunction!\n");
     969      145480 :   fMap.clear(); // Simply discard the function level map
     970      145480 :   TheFunction = nullptr;
     971      145480 :   FunctionProcessed = false;
     972             :   ST_DEBUG("end purgeFunction!\n");
     973      145480 : }
     974             : 
     975             : /// getGlobalSlot - Get the slot number of a global value.
     976       11960 : int SlotTracker::getGlobalSlot(const GlobalValue *V) {
     977             :   // Check for uninitialized state and do lazy initialization.
     978       11960 :   initialize();
     979             : 
     980             :   // Find the value in the module map
     981       11960 :   ValueMap::iterator MI = mMap.find(V);
     982       35880 :   return MI == mMap.end() ? -1 : (int)MI->second;
     983             : }
     984             : 
     985             : /// getMetadataSlot - Get the slot number of a MDNode.
     986      174468 : int SlotTracker::getMetadataSlot(const MDNode *N) {
     987             :   // Check for uninitialized state and do lazy initialization.
     988      174468 :   initialize();
     989             : 
     990             :   // Find the MDNode in the module map
     991      174468 :   mdn_iterator MI = mdnMap.find(N);
     992      523404 :   return MI == mdnMap.end() ? -1 : (int)MI->second;
     993             : }
     994             : 
     995             : /// getLocalSlot - Get the slot number for a value that is local to a function.
     996     1055996 : int SlotTracker::getLocalSlot(const Value *V) {
     997             :   assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
     998             : 
     999             :   // Check for uninitialized state and do lazy initialization.
    1000     1055996 :   initialize();
    1001             : 
    1002     1055996 :   ValueMap::iterator FI = fMap.find(V);
    1003     3167988 :   return FI == fMap.end() ? -1 : (int)FI->second;
    1004             : }
    1005             : 
    1006      141556 : int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
    1007             :   // Check for uninitialized state and do lazy initialization.
    1008      141556 :   initialize();
    1009             : 
    1010             :   // Find the AttributeSet in the module map.
    1011      141556 :   as_iterator AI = asMap.find(AS);
    1012      424668 :   return AI == asMap.end() ? -1 : (int)AI->second;
    1013             : }
    1014             : 
    1015             : /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
    1016        3352 : void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
    1017             :   assert(V && "Can't insert a null Value into SlotTracker!");
    1018             :   assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
    1019             :   assert(!V->hasName() && "Doesn't need a slot!");
    1020             : 
    1021        3352 :   unsigned DestSlot = mNext++;
    1022        6704 :   mMap[V] = DestSlot;
    1023             : 
    1024             :   ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
    1025             :            DestSlot << " [");
    1026             :   // G = Global, F = Function, A = Alias, I = IFunc, o = other
    1027             :   ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
    1028             :             (isa<Function>(V) ? 'F' :
    1029             :              (isa<GlobalAlias>(V) ? 'A' :
    1030             :               (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
    1031        3352 : }
    1032             : 
    1033             : /// CreateSlot - Create a new slot for the specified value if it has no name.
    1034      661254 : void SlotTracker::CreateFunctionSlot(const Value *V) {
    1035             :   assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
    1036             : 
    1037      661254 :   unsigned DestSlot = fNext++;
    1038     1322508 :   fMap[V] = DestSlot;
    1039             : 
    1040             :   // G = Global, F = Function, o = other
    1041             :   ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
    1042             :            DestSlot << " [o]\n");
    1043      661254 : }
    1044             : 
    1045             : /// CreateModuleSlot - Insert the specified MDNode* into the slot table.
    1046      245678 : void SlotTracker::CreateMetadataSlot(const MDNode *N) {
    1047             :   assert(N && "Can't insert a null Value into SlotTracker!");
    1048             : 
    1049             :   // Don't make slots for DIExpressions. We just print them inline everywhere.
    1050      491356 :   if (isa<DIExpression>(N))
    1051             :     return;
    1052             : 
    1053      241560 :   unsigned DestSlot = mdnNext;
    1054      724680 :   if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
    1055             :     return;
    1056       91371 :   ++mdnNext;
    1057             : 
    1058             :   // Recursively add any MDNodes referenced by operands.
    1059      369558 :   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
    1060      666562 :     if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
    1061      110188 :       CreateMetadataSlot(Op);
    1062             : }
    1063             : 
    1064      209488 : void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
    1065             :   assert(AS.hasAttributes() && "Doesn't need a slot!");
    1066             : 
    1067      209488 :   as_iterator I = asMap.find(AS);
    1068      628464 :   if (I != asMap.end())
    1069      181978 :     return;
    1070             : 
    1071       27510 :   unsigned DestSlot = asNext++;
    1072       55020 :   asMap[AS] = DestSlot;
    1073             : }
    1074             : 
    1075             : //===----------------------------------------------------------------------===//
    1076             : // AsmWriter Implementation
    1077             : //===----------------------------------------------------------------------===//
    1078             : 
    1079             : static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
    1080             :                                    TypePrinting *TypePrinter,
    1081             :                                    SlotTracker *Machine,
    1082             :                                    const Module *Context);
    1083             : 
    1084             : static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
    1085             :                                    TypePrinting *TypePrinter,
    1086             :                                    SlotTracker *Machine, const Module *Context,
    1087             :                                    bool FromValue = false);
    1088             : 
    1089         703 : static void writeAtomicRMWOperation(raw_ostream &Out,
    1090             :                                     AtomicRMWInst::BinOp Op) {
    1091         703 :   switch (Op) {
    1092           0 :   default: Out << " <unknown operation " << Op << ">"; break;
    1093          95 :   case AtomicRMWInst::Xchg: Out << " xchg"; break;
    1094         171 :   case AtomicRMWInst::Add:  Out << " add"; break;
    1095          96 :   case AtomicRMWInst::Sub:  Out << " sub"; break;
    1096          79 :   case AtomicRMWInst::And:  Out << " and"; break;
    1097          41 :   case AtomicRMWInst::Nand: Out << " nand"; break;
    1098          75 :   case AtomicRMWInst::Or:   Out << " or"; break;
    1099          64 :   case AtomicRMWInst::Xor:  Out << " xor"; break;
    1100          22 :   case AtomicRMWInst::Max:  Out << " max"; break;
    1101          24 :   case AtomicRMWInst::Min:  Out << " min"; break;
    1102          18 :   case AtomicRMWInst::UMax: Out << " umax"; break;
    1103          18 :   case AtomicRMWInst::UMin: Out << " umin"; break;
    1104             :   }
    1105         703 : }
    1106             : 
    1107     1435801 : static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
    1108       65464 :   if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
    1109             :     // Unsafe algebra implies all the others, no need to write them all out
    1110       65464 :     if (FPO->hasUnsafeAlgebra())
    1111        2248 :       Out << " fast";
    1112             :     else {
    1113       63216 :       if (FPO->hasNoNaNs())
    1114         199 :         Out << " nnan";
    1115       63216 :       if (FPO->hasNoInfs())
    1116          52 :         Out << " ninf";
    1117       63216 :       if (FPO->hasNoSignedZeros())
    1118          40 :         Out << " nsz";
    1119       63216 :       if (FPO->hasAllowReciprocal())
    1120          39 :         Out << " arcp";
    1121       63216 :       if (FPO->hasAllowContract())
    1122          39 :         Out << " contract";
    1123             :     }
    1124             :   }
    1125             : 
    1126       47912 :   if (const OverflowingBinaryOperator *OBO =
    1127       47912 :         dyn_cast<OverflowingBinaryOperator>(U)) {
    1128       47912 :     if (OBO->hasNoUnsignedWrap())
    1129        4625 :       Out << " nuw";
    1130       47912 :     if (OBO->hasNoSignedWrap())
    1131       23814 :       Out << " nsw";
    1132        6443 :   } else if (const PossiblyExactOperator *Div =
    1133        6443 :                dyn_cast<PossiblyExactOperator>(U)) {
    1134        6443 :     if (Div->isExact())
    1135         338 :       Out << " exact";
    1136      120595 :   } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
    1137      120595 :     if (GEP->isInBounds())
    1138      108178 :       Out << " inbounds";
    1139             :   }
    1140     1435801 : }
    1141             : 
    1142      810983 : static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
    1143             :                                   TypePrinting &TypePrinter,
    1144             :                                   SlotTracker *Machine,
    1145             :                                   const Module *Context) {
    1146     1411434 :   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
    1147      600451 :     if (CI->getType()->isIntegerTy(1)) {
    1148       19370 :       Out << (CI->getZExtValue() ? "true" : "false");
    1149       19370 :       return;
    1150             :     }
    1151      581081 :     Out << CI->getValue();
    1152             :     return;
    1153             :   }
    1154             : 
    1155      223327 :   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
    1156       12795 :     const APFloat &APF = CFP->getValueAPF();
    1157       18186 :     if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
    1158        5391 :         &APF.getSemantics() == &APFloat::IEEEdouble()) {
    1159             :       // We would like to output the FP constant value in exponential notation,
    1160             :       // but we cannot do this if doing so will lose precision.  Check here to
    1161             :       // make sure that we only output it in exponential format if we can parse
    1162             :       // the value back and get the same value.
    1163             :       //
    1164             :       bool ignored;
    1165       12142 :       bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
    1166       12142 :       bool isInf = APF.isInfinity();
    1167       12142 :       bool isNaN = APF.isNaN();
    1168       12142 :       if (!isInf && !isNaN) {
    1169       11660 :         double Val = isDouble ? APF.convertToDouble() : APF.convertToFloat();
    1170       12090 :         SmallString<128> StrVal;
    1171       11660 :         APF.toString(StrVal, 6, 0, false);
    1172             :         // Check to make sure that the stringized number is not some string like
    1173             :         // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
    1174             :         // that the string matches the "[-+]?[0-9]" regex.
    1175             :         //
    1176             :         assert(((StrVal[0] >= '0' && StrVal[0] <= '9') ||
    1177             :                 ((StrVal[0] == '-' || StrVal[0] == '+') &&
    1178             :                  (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
    1179             :                "[-+]?[0-9] regex does not match!");
    1180             :         // Reparse stringized version!
    1181       23320 :         if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
    1182       11230 :           Out << StrVal;
    1183       11230 :           return;
    1184             :         }
    1185             :       }
    1186             :       // Otherwise we could not reparse it to exactly the same value, so we must
    1187             :       // output the string in hexadecimal format!  Note that loading and storing
    1188             :       // floating point types changes the bits of NaNs on some hosts, notably
    1189             :       // x86, so we must not use these types.
    1190             :       static_assert(sizeof(double) == sizeof(uint64_t),
    1191             :                     "assuming that double is 64 bits!");
    1192         912 :       APFloat apf = APF;
    1193             :       // Floats are represented in ASCII IR as double, convert.
    1194         912 :       if (!isDouble)
    1195         578 :         apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
    1196             :                           &ignored);
    1197        3648 :       Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
    1198             :       return;
    1199             :     }
    1200             : 
    1201             :     // Either half, or some form of long double.
    1202             :     // These appear as a magic letter identifying the type, then a
    1203             :     // fixed number of hex digits.
    1204         653 :     Out << "0x";
    1205         653 :     APInt API = APF.bitcastToAPInt();
    1206         653 :     if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
    1207         203 :       Out << 'K';
    1208         609 :       Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
    1209         203 :                                   /*Upper=*/true);
    1210         609 :       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
    1211         203 :                                   /*Upper=*/true);
    1212         203 :       return;
    1213         450 :     } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
    1214         154 :       Out << 'L';
    1215         462 :       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
    1216         154 :                                   /*Upper=*/true);
    1217         462 :       Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
    1218         154 :                                   /*Upper=*/true);
    1219         296 :     } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
    1220          26 :       Out << 'M';
    1221          78 :       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
    1222          26 :                                   /*Upper=*/true);
    1223          78 :       Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
    1224          26 :                                   /*Upper=*/true);
    1225         270 :     } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
    1226         270 :       Out << 'H';
    1227         270 :       Out << format_hex_no_prefix(API.getZExtValue(), 4,
    1228         270 :                                   /*Upper=*/true);
    1229             :     } else
    1230           0 :       llvm_unreachable("Unsupported floating point type");
    1231             :     return;
    1232             :   }
    1233             : 
    1234      395474 :   if (isa<ConstantAggregateZero>(CV)) {
    1235       12673 :     Out << "zeroinitializer";
    1236       12673 :     return;
    1237             :   }
    1238             : 
    1239      185349 :   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
    1240         285 :     Out << "blockaddress(";
    1241         285 :     WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
    1242             :                            Context);
    1243         285 :     Out << ", ";
    1244         285 :     WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
    1245             :                            Context);
    1246         285 :     Out << ")";
    1247         285 :     return;
    1248             :   }
    1249             : 
    1250      190429 :   if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
    1251        5650 :     Type *ETy = CA->getType()->getElementType();
    1252        5650 :     Out << '[';
    1253        5650 :     TypePrinter.print(ETy, Out);
    1254        5650 :     Out << ' ';
    1255       11300 :     WriteAsOperandInternal(Out, CA->getOperand(0),
    1256             :                            &TypePrinter, Machine,
    1257             :                            Context);
    1258       26954 :     for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
    1259       15654 :       Out << ", ";
    1260       15654 :       TypePrinter.print(ETy, Out);
    1261       15654 :       Out << ' ';
    1262       31308 :       WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
    1263             :                              Context);
    1264             :     }
    1265             :     Out << ']';
    1266             :     return;
    1267             :   }
    1268             : 
    1269      195010 :   if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
    1270             :     // As a special case, print the array as a string if it is an array of
    1271             :     // i8 with ConstantInt values.
    1272       15881 :     if (CA->isString()) {
    1273       11991 :       Out << "c\"";
    1274       23982 :       PrintEscapedString(CA->getAsString(), Out);
    1275             :       Out << '"';
    1276             :       return;
    1277             :     }
    1278             : 
    1279        3890 :     Type *ETy = CA->getType()->getElementType();
    1280        3890 :     Out << '[';
    1281        3890 :     TypePrinter.print(ETy, Out);
    1282        3890 :     Out << ' ';
    1283        3890 :     WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
    1284             :                            &TypePrinter, Machine,
    1285             :                            Context);
    1286       10795 :     for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
    1287        6905 :       Out << ", ";
    1288        6905 :       TypePrinter.print(ETy, Out);
    1289        6905 :       Out << ' ';
    1290        6905 :       WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
    1291             :                              Machine, Context);
    1292             :     }
    1293             :     Out << ']';
    1294             :     return;
    1295             :   }
    1296             : 
    1297      181462 :   if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
    1298       36428 :     if (CS->getType()->isPacked())
    1299             :       Out << '<';
    1300       18214 :     Out << '{';
    1301       36428 :     unsigned N = CS->getNumOperands();
    1302       18214 :     if (N) {
    1303       18214 :       Out << ' ';
    1304       36428 :       TypePrinter.print(CS->getOperand(0)->getType(), Out);
    1305       18214 :       Out << ' ';
    1306             : 
    1307       36428 :       WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
    1308             :                              Context);
    1309             : 
    1310       72557 :       for (unsigned i = 1; i < N; i++) {
    1311       54343 :         Out << ", ";
    1312      108686 :         TypePrinter.print(CS->getOperand(i)->getType(), Out);
    1313       54343 :         Out << ' ';
    1314             : 
    1315      108686 :         WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
    1316             :                                Context);
    1317             :       }
    1318             :       Out << ' ';
    1319             :     }
    1320             : 
    1321       18214 :     Out << '}';
    1322       36428 :     if (CS->getType()->isPacked())
    1323             :       Out << '>';
    1324             :     return;
    1325             :   }
    1326             : 
    1327      432837 :   if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
    1328       33248 :     Type *ETy = CV->getType()->getVectorElementType();
    1329       16624 :     Out << '<';
    1330       16624 :     TypePrinter.print(ETy, Out);
    1331       16624 :     Out << ' ';
    1332       16624 :     WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
    1333             :                            Machine, Context);
    1334      157932 :     for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
    1335      124684 :       Out << ", ";
    1336      124684 :       TypePrinter.print(ETy, Out);
    1337      124684 :       Out << ' ';
    1338      124684 :       WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
    1339             :                              Machine, Context);
    1340             :     }
    1341             :     Out << '>';
    1342             :     return;
    1343             :   }
    1344             : 
    1345      256820 :   if (isa<ConstantPointerNull>(CV)) {
    1346       18074 :     Out << "null";
    1347       18074 :     return;
    1348             :   }
    1349             : 
    1350      220672 :   if (isa<ConstantTokenNone>(CV)) {
    1351         456 :     Out << "none";
    1352         456 :     return;
    1353             :   }
    1354             : 
    1355      219760 :   if (isa<UndefValue>(CV)) {
    1356       33544 :     Out << "undef";
    1357       33544 :     return;
    1358             :   }
    1359             : 
    1360      152672 :   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
    1361       76336 :     Out << CE->getOpcodeName();
    1362       76336 :     WriteOptimizationInfo(Out, CE);
    1363       76336 :     if (CE->isCompare())
    1364         382 :       Out << ' ' << CmpInst::getPredicateName(
    1365         191 :                         static_cast<CmpInst::Predicate>(CE->getPredicate()));
    1366       76336 :     Out << " (";
    1367             : 
    1368      152672 :     Optional<unsigned> InRangeOp;
    1369       36233 :     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
    1370       36233 :       TypePrinter.print(GEP->getSourceElementType(), Out);
    1371       36233 :       Out << ", ";
    1372      108699 :       InRangeOp = GEP->getInRangeIndex();
    1373       36233 :       if (InRangeOp)
    1374        1174 :         ++*InRangeOp;
    1375             :     }
    1376             : 
    1377      303780 :     for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
    1378      160498 :       if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
    1379        1174 :         Out << "inrange ";
    1380      151108 :       TypePrinter.print((*OI)->getType(), Out);
    1381      151108 :       Out << ' ';
    1382      151108 :       WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
    1383      302216 :       if (OI+1 != CE->op_end())
    1384       74772 :         Out << ", ";
    1385             :     }
    1386             : 
    1387       76336 :     if (CE->hasIndices()) {
    1388           2 :       ArrayRef<unsigned> Indices = CE->getIndices();
    1389           4 :       for (unsigned i = 0, e = Indices.size(); i != e; ++i)
    1390           6 :         Out << ", " << Indices[i];
    1391             :     }
    1392             : 
    1393       76336 :     if (CE->isCast()) {
    1394       38231 :       Out << " to ";
    1395       38231 :       TypePrinter.print(CE->getType(), Out);
    1396             :     }
    1397             : 
    1398       76336 :     Out << ')';
    1399             :     return;
    1400             :   }
    1401             : 
    1402           0 :   Out << "<placeholder or erroneous Constant>";
    1403             : }
    1404             : 
    1405       38715 : static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
    1406             :                          TypePrinting *TypePrinter, SlotTracker *Machine,
    1407             :                          const Module *Context) {
    1408       38715 :   Out << "!{";
    1409       38715 :   for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
    1410      296988 :     const Metadata *MD = Node->getOperand(mi);
    1411       98996 :     if (!MD)
    1412         844 :       Out << "null";
    1413       98152 :     else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
    1414       44754 :       Value *V = MDV->getValue();
    1415       44754 :       TypePrinter->print(V->getType(), Out);
    1416       44754 :       Out << ' ';
    1417       44754 :       WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
    1418             :     } else {
    1419       53398 :       WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
    1420             :     }
    1421       98996 :     if (mi + 1 != me)
    1422       61890 :       Out << ", ";
    1423             :   }
    1424             : 
    1425       38715 :   Out << "}";
    1426       38715 : }
    1427             : 
    1428             : namespace {
    1429             : 
    1430             : struct FieldSeparator {
    1431             :   bool Skip = true;
    1432             :   const char *Sep;
    1433             : 
    1434       35996 :   FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
    1435             : };
    1436             : 
    1437             : raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
    1438      125125 :   if (FS.Skip) {
    1439       26511 :     FS.Skip = false;
    1440             :     return OS;
    1441             :   }
    1442       93139 :   return OS << FS.Sep;
    1443             : }
    1444             : 
    1445             : struct MDFieldPrinter {
    1446             :   raw_ostream &Out;
    1447             :   FieldSeparator FS;
    1448             :   TypePrinting *TypePrinter = nullptr;
    1449             :   SlotTracker *Machine = nullptr;
    1450             :   const Module *Context = nullptr;
    1451             : 
    1452        4690 :   explicit MDFieldPrinter(raw_ostream &Out) : Out(Out) {}
    1453             :   MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
    1454             :                  SlotTracker *Machine, const Module *Context)
    1455       48356 :       : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
    1456             :   }
    1457             : 
    1458             :   void printTag(const DINode *N);
    1459             :   void printMacinfoType(const DIMacroNode *N);
    1460             :   void printChecksumKind(const DIFile *N);
    1461             :   void printString(StringRef Name, StringRef Value,
    1462             :                    bool ShouldSkipEmpty = true);
    1463             :   void printMetadata(StringRef Name, const Metadata *MD,
    1464             :                      bool ShouldSkipNull = true);
    1465             :   template <class IntTy>
    1466             :   void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
    1467             :   void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
    1468             :   void printDIFlags(StringRef Name, DINode::DIFlags Flags);
    1469             :   template <class IntTy, class Stringifier>
    1470             :   void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
    1471             :                       bool ShouldSkipZero = true);
    1472             :   void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
    1473             : };
    1474             : 
    1475             : } // end anonymous namespace
    1476             : 
    1477        4353 : void MDFieldPrinter::printTag(const DINode *N) {
    1478        8706 :   Out << FS << "tag: ";
    1479        8706 :   auto Tag = dwarf::TagString(N->getTag());
    1480        4353 :   if (!Tag.empty())
    1481        4348 :     Out << Tag;
    1482             :   else
    1483           5 :     Out << N->getTag();
    1484        4353 : }
    1485             : 
    1486        1070 : void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
    1487        2140 :   Out << FS << "type: ";
    1488        2140 :   auto Type = dwarf::MacinfoString(N->getMacinfoType());
    1489        1070 :   if (!Type.empty())
    1490        1070 :     Out << Type;
    1491             :   else
    1492           0 :     Out << N->getMacinfoType();
    1493        1070 : }
    1494             : 
    1495        1308 : void MDFieldPrinter::printChecksumKind(const DIFile *N) {
    1496        1308 :   if (N->getChecksumKind() == DIFile::CSK_None)
    1497             :     // Skip CSK_None checksum kind.
    1498             :     return;
    1499          68 :   Out << FS << "checksumkind: " << N->getChecksumKindAsString();
    1500             : }
    1501             : 
    1502       26057 : void MDFieldPrinter::printString(StringRef Name, StringRef Value,
    1503             :                                  bool ShouldSkipEmpty) {
    1504       49438 :   if (ShouldSkipEmpty && Value.empty())
    1505             :     return;
    1506             : 
    1507       34876 :   Out << FS << Name << ": \"";
    1508       17438 :   PrintEscapedString(Value, Out);
    1509       17438 :   Out << "\"";
    1510             : }
    1511             : 
    1512       47053 : static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
    1513             :                                    TypePrinting *TypePrinter,
    1514             :                                    SlotTracker *Machine,
    1515             :                                    const Module *Context) {
    1516       47053 :   if (!MD) {
    1517         300 :     Out << "null";
    1518         300 :     return;
    1519             :   }
    1520       46753 :   WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
    1521             : }
    1522             : 
    1523       83677 : void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
    1524             :                                    bool ShouldSkipNull) {
    1525       83677 :   if (ShouldSkipNull && !MD)
    1526             :     return;
    1527             : 
    1528       94076 :   Out << FS << Name << ": ";
    1529       47038 :   writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
    1530             : }
    1531             : 
    1532             : template <class IntTy>
    1533       58535 : void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
    1534       58535 :   if (ShouldSkipZero && !Int)
    1535             :     return;
    1536             : 
    1537       58114 :   Out << FS << Name << ": " << Int;
    1538             : }
    1539             : 
    1540       13363 : void MDFieldPrinter::printBool(StringRef Name, bool Value,
    1541             :                                Optional<bool> Default) {
    1542       16086 :   if (Default && Value == *Default)
    1543             :     return;
    1544       21320 :   Out << FS << Name << ": " << (Value ? "true" : "false");
    1545             : }
    1546             : 
    1547       11848 : void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
    1548       11848 :   if (!Flags)
    1549        6693 :     return;
    1550             : 
    1551       10310 :   Out << FS << Name << ": ";
    1552             : 
    1553       10310 :   SmallVector<DINode::DIFlags, 8> SplitFlags;
    1554        5155 :   auto Extra = DINode::splitFlags(Flags, SplitFlags);
    1555             : 
    1556        5155 :   FieldSeparator FlagsFS(" | ");
    1557       22020 :   for (auto F : SplitFlags) {
    1558        6555 :     auto StringF = DINode::getFlagString(F);
    1559             :     assert(!StringF.empty() && "Expected valid flag");
    1560       13110 :     Out << FlagsFS << StringF;
    1561             :   }
    1562        5155 :   if (Extra || SplitFlags.empty())
    1563           0 :     Out << FlagsFS << Extra;
    1564             : }
    1565             : 
    1566         873 : void MDFieldPrinter::printEmissionKind(StringRef Name,
    1567             :                                        DICompileUnit::DebugEmissionKind EK) {
    1568        1746 :   Out << FS << Name << ": " << DICompileUnit::EmissionKindString(EK);
    1569         873 : }
    1570             : 
    1571             : template <class IntTy, class Stringifier>
    1572        7371 : void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
    1573             :                                     Stringifier toString, bool ShouldSkipZero) {
    1574        7371 :   if (!Value)
    1575        5552 :     return;
    1576             : 
    1577        3638 :   Out << FS << Name << ": ";
    1578        1819 :   auto S = toString(Value);
    1579        1819 :   if (!S.empty())
    1580        1819 :     Out << S;
    1581             :   else
    1582           0 :     Out << Value;
    1583             : }
    1584             : 
    1585          20 : static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
    1586             :                                TypePrinting *TypePrinter, SlotTracker *Machine,
    1587             :                                const Module *Context) {
    1588          20 :   Out << "!GenericDINode(";
    1589          20 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1590          20 :   Printer.printTag(N);
    1591          40 :   Printer.printString("header", N->getHeader());
    1592          20 :   if (N->getNumDwarfOperands()) {
    1593           5 :     Out << Printer.FS << "operands: {";
    1594           5 :     FieldSeparator IFS;
    1595          20 :     for (auto &I : N->dwarf_operands()) {
    1596          15 :       Out << IFS;
    1597          15 :       writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
    1598             :     }
    1599           5 :     Out << "}";
    1600             :   }
    1601          20 :   Out << ")";
    1602          20 : }
    1603             : 
    1604        7749 : static void writeDILocation(raw_ostream &Out, const DILocation *DL,
    1605             :                             TypePrinting *TypePrinter, SlotTracker *Machine,
    1606             :                             const Module *Context) {
    1607        7749 :   Out << "!DILocation(";
    1608        7749 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1609             :   // Always output the line, since 0 is a relevant and important value for it.
    1610       15498 :   Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
    1611       23247 :   Printer.printInt("column", DL->getColumn());
    1612       15498 :   Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
    1613       15498 :   Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
    1614        7749 :   Out << ")";
    1615        7749 : }
    1616             : 
    1617         238 : static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
    1618             :                             TypePrinting *, SlotTracker *, const Module *) {
    1619         238 :   Out << "!DISubrange(";
    1620         238 :   MDFieldPrinter Printer(Out);
    1621         476 :   Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
    1622         476 :   Printer.printInt("lowerBound", N->getLowerBound());
    1623         238 :   Out << ")";
    1624         238 : }
    1625             : 
    1626          60 : static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
    1627             :                               TypePrinting *, SlotTracker *, const Module *) {
    1628          60 :   Out << "!DIEnumerator(";
    1629          60 :   MDFieldPrinter Printer(Out);
    1630         120 :   Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
    1631         120 :   Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
    1632          60 :   Out << ")";
    1633          60 : }
    1634             : 
    1635         739 : static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
    1636             :                              TypePrinting *, SlotTracker *, const Module *) {
    1637         739 :   Out << "!DIBasicType(";
    1638         739 :   MDFieldPrinter Printer(Out);
    1639         739 :   if (N->getTag() != dwarf::DW_TAG_base_type)
    1640           7 :     Printer.printTag(N);
    1641        2217 :   Printer.printString("name", N->getName());
    1642        1478 :   Printer.printInt("size", N->getSizeInBits());
    1643        1478 :   Printer.printInt("align", N->getAlignInBits());
    1644        1478 :   Printer.printDwarfEnum("encoding", N->getEncoding(),
    1645             :                          dwarf::AttributeEncodingString);
    1646         739 :   Out << ")";
    1647         739 : }
    1648             : 
    1649        2885 : static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
    1650             :                                TypePrinting *TypePrinter, SlotTracker *Machine,
    1651             :                                const Module *Context) {
    1652        2885 :   Out << "!DIDerivedType(";
    1653        2885 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1654        2885 :   Printer.printTag(N);
    1655        8655 :   Printer.printString("name", N->getName());
    1656        8655 :   Printer.printMetadata("scope", N->getRawScope());
    1657        8655 :   Printer.printMetadata("file", N->getRawFile());
    1658        5770 :   Printer.printInt("line", N->getLine());
    1659        5770 :   Printer.printMetadata("baseType", N->getRawBaseType(),
    1660             :                         /* ShouldSkipNull */ false);
    1661        5770 :   Printer.printInt("size", N->getSizeInBits());
    1662        5770 :   Printer.printInt("align", N->getAlignInBits());
    1663        5770 :   Printer.printInt("offset", N->getOffsetInBits());
    1664        5770 :   Printer.printDIFlags("flags", N->getFlags());
    1665        5770 :   Printer.printMetadata("extraData", N->getRawExtraData());
    1666        5770 :   if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
    1667          48 :     Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
    1668             :                      /* ShouldSkipZero */ false);
    1669        2885 :   Out << ")";
    1670        2885 : }
    1671             : 
    1672        1356 : static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
    1673             :                                  TypePrinting *TypePrinter,
    1674             :                                  SlotTracker *Machine, const Module *Context) {
    1675        1356 :   Out << "!DICompositeType(";
    1676        1356 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1677        1356 :   Printer.printTag(N);
    1678        4068 :   Printer.printString("name", N->getName());
    1679        4068 :   Printer.printMetadata("scope", N->getRawScope());
    1680        4068 :   Printer.printMetadata("file", N->getRawFile());
    1681        2712 :   Printer.printInt("line", N->getLine());
    1682        2712 :   Printer.printMetadata("baseType", N->getRawBaseType());
    1683        2712 :   Printer.printInt("size", N->getSizeInBits());
    1684        2712 :   Printer.printInt("align", N->getAlignInBits());
    1685        2712 :   Printer.printInt("offset", N->getOffsetInBits());
    1686        2712 :   Printer.printDIFlags("flags", N->getFlags());
    1687        2712 :   Printer.printMetadata("elements", N->getRawElements());
    1688        2712 :   Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
    1689             :                          dwarf::LanguageString);
    1690        2712 :   Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
    1691        2712 :   Printer.printMetadata("templateParams", N->getRawTemplateParams());
    1692        2712 :   Printer.printString("identifier", N->getIdentifier());
    1693        1356 :   Out << ")";
    1694        1356 : }
    1695             : 
    1696        1514 : static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
    1697             :                                   TypePrinting *TypePrinter,
    1698             :                                   SlotTracker *Machine, const Module *Context) {
    1699        1514 :   Out << "!DISubroutineType(";
    1700        1514 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1701        3028 :   Printer.printDIFlags("flags", N->getFlags());
    1702        3028 :   Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
    1703        3028 :   Printer.printMetadata("types", N->getRawTypeArray(),
    1704             :                         /* ShouldSkipNull */ false);
    1705        1514 :   Out << ")";
    1706        1514 : }
    1707             : 
    1708        1308 : static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
    1709             :                         SlotTracker *, const Module *) {
    1710        1308 :   Out << "!DIFile(";
    1711        1308 :   MDFieldPrinter Printer(Out);
    1712        2616 :   Printer.printString("filename", N->getFilename(),
    1713             :                       /* ShouldSkipEmpty */ false);
    1714        2616 :   Printer.printString("directory", N->getDirectory(),
    1715             :                       /* ShouldSkipEmpty */ false);
    1716        1308 :   Printer.printChecksumKind(N);
    1717        2616 :   Printer.printString("checksum", N->getChecksum(), /* ShouldSkipEmpty */ true);
    1718        1308 :   Out << ")";
    1719        1308 : }
    1720             : 
    1721         873 : static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
    1722             :                                TypePrinting *TypePrinter, SlotTracker *Machine,
    1723             :                                const Module *Context) {
    1724         873 :   Out << "!DICompileUnit(";
    1725         873 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1726        1746 :   Printer.printDwarfEnum("language", N->getSourceLanguage(),
    1727             :                          dwarf::LanguageString, /* ShouldSkipZero */ false);
    1728        2619 :   Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
    1729        1746 :   Printer.printString("producer", N->getProducer());
    1730        2619 :   Printer.printBool("isOptimized", N->isOptimized());
    1731        1746 :   Printer.printString("flags", N->getFlags());
    1732        1746 :   Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
    1733             :                    /* ShouldSkipZero */ false);
    1734        1746 :   Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
    1735        1746 :   Printer.printEmissionKind("emissionKind", N->getEmissionKind());
    1736        1746 :   Printer.printMetadata("enums", N->getRawEnumTypes());
    1737        1746 :   Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
    1738        1746 :   Printer.printMetadata("globals", N->getRawGlobalVariables());
    1739        1746 :   Printer.printMetadata("imports", N->getRawImportedEntities());
    1740        1746 :   Printer.printMetadata("macros", N->getRawMacros());
    1741        1746 :   Printer.printInt("dwoId", N->getDWOId());
    1742        3492 :   Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
    1743        3492 :   Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
    1744             :                     false);
    1745        3492 :   Printer.printBool("gnuPubnames", N->getGnuPubnames(), false);
    1746         873 :   Out << ")";
    1747         873 : }
    1748             : 
    1749        2889 : static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
    1750             :                               TypePrinting *TypePrinter, SlotTracker *Machine,
    1751             :                               const Module *Context) {
    1752        2889 :   Out << "!DISubprogram(";
    1753        2889 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1754        5778 :   Printer.printString("name", N->getName());
    1755        5778 :   Printer.printString("linkageName", N->getLinkageName());
    1756        5778 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1757        8667 :   Printer.printMetadata("file", N->getRawFile());
    1758        5778 :   Printer.printInt("line", N->getLine());
    1759        5778 :   Printer.printMetadata("type", N->getRawType());
    1760       11556 :   Printer.printBool("isLocal", N->isLocalToUnit());
    1761       11556 :   Printer.printBool("isDefinition", N->isDefinition());
    1762        5778 :   Printer.printInt("scopeLine", N->getScopeLine());
    1763        5778 :   Printer.printMetadata("containingType", N->getRawContainingType());
    1764        5778 :   Printer.printDwarfEnum("virtuality", N->getVirtuality(),
    1765             :                          dwarf::VirtualityString);
    1766        5726 :   if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
    1767        2837 :       N->getVirtualIndex() != 0)
    1768         394 :     Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
    1769        5778 :   Printer.printInt("thisAdjustment", N->getThisAdjustment());
    1770        5778 :   Printer.printDIFlags("flags", N->getFlags());
    1771       11556 :   Printer.printBool("isOptimized", N->isOptimized());
    1772        5778 :   Printer.printMetadata("unit", N->getRawUnit());
    1773        5778 :   Printer.printMetadata("templateParams", N->getRawTemplateParams());
    1774        5778 :   Printer.printMetadata("declaration", N->getRawDeclaration());
    1775        5778 :   Printer.printMetadata("variables", N->getRawVariables());
    1776        5778 :   Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
    1777        2889 :   Out << ")";
    1778        2889 : }
    1779             : 
    1780         592 : static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
    1781             :                                 TypePrinting *TypePrinter, SlotTracker *Machine,
    1782             :                                 const Module *Context) {
    1783         592 :   Out << "!DILexicalBlock(";
    1784         592 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1785        1776 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1786        1776 :   Printer.printMetadata("file", N->getRawFile());
    1787        1184 :   Printer.printInt("line", N->getLine());
    1788        1776 :   Printer.printInt("column", N->getColumn());
    1789         592 :   Out << ")";
    1790         592 : }
    1791             : 
    1792         242 : static void writeDILexicalBlockFile(raw_ostream &Out,
    1793             :                                     const DILexicalBlockFile *N,
    1794             :                                     TypePrinting *TypePrinter,
    1795             :                                     SlotTracker *Machine,
    1796             :                                     const Module *Context) {
    1797         242 :   Out << "!DILexicalBlockFile(";
    1798         242 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1799         726 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1800         726 :   Printer.printMetadata("file", N->getRawFile());
    1801         484 :   Printer.printInt("discriminator", N->getDiscriminator(),
    1802             :                    /* ShouldSkipZero */ false);
    1803         242 :   Out << ")";
    1804         242 : }
    1805             : 
    1806         104 : static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
    1807             :                              TypePrinting *TypePrinter, SlotTracker *Machine,
    1808             :                              const Module *Context) {
    1809         104 :   Out << "!DINamespace(";
    1810         104 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1811         208 :   Printer.printString("name", N->getName());
    1812         208 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1813         520 :   Printer.printBool("exportSymbols", N->getExportSymbols(), false);
    1814         104 :   Out << ")";
    1815         104 : }
    1816             : 
    1817        1070 : static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
    1818             :                          TypePrinting *TypePrinter, SlotTracker *Machine,
    1819             :                          const Module *Context) {
    1820        1070 :   Out << "!DIMacro(";
    1821        1070 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1822        1070 :   Printer.printMacinfoType(N);
    1823        2140 :   Printer.printInt("line", N->getLine());
    1824        2140 :   Printer.printString("name", N->getName());
    1825        2140 :   Printer.printString("value", N->getValue());
    1826        1070 :   Out << ")";
    1827        1070 : }
    1828             : 
    1829          35 : static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
    1830             :                              TypePrinting *TypePrinter, SlotTracker *Machine,
    1831             :                              const Module *Context) {
    1832          35 :   Out << "!DIMacroFile(";
    1833          35 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1834          70 :   Printer.printInt("line", N->getLine());
    1835          70 :   Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
    1836          70 :   Printer.printMetadata("nodes", N->getRawElements());
    1837          35 :   Out << ")";
    1838          35 : }
    1839             : 
    1840          36 : static void writeDIModule(raw_ostream &Out, const DIModule *N,
    1841             :                           TypePrinting *TypePrinter, SlotTracker *Machine,
    1842             :                           const Module *Context) {
    1843          36 :   Out << "!DIModule(";
    1844          36 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1845          72 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1846          72 :   Printer.printString("name", N->getName());
    1847          72 :   Printer.printString("configMacros", N->getConfigurationMacros());
    1848          72 :   Printer.printString("includePath", N->getIncludePath());
    1849          72 :   Printer.printString("isysroot", N->getISysRoot());
    1850          36 :   Out << ")";
    1851          36 : }
    1852             : 
    1853             : 
    1854         132 : static void writeDITemplateTypeParameter(raw_ostream &Out,
    1855             :                                          const DITemplateTypeParameter *N,
    1856             :                                          TypePrinting *TypePrinter,
    1857             :                                          SlotTracker *Machine,
    1858             :                                          const Module *Context) {
    1859         132 :   Out << "!DITemplateTypeParameter(";
    1860         132 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1861         396 :   Printer.printString("name", N->getName());
    1862         396 :   Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
    1863         132 :   Out << ")";
    1864         132 : }
    1865             : 
    1866         260 : static void writeDITemplateValueParameter(raw_ostream &Out,
    1867             :                                           const DITemplateValueParameter *N,
    1868             :                                           TypePrinting *TypePrinter,
    1869             :                                           SlotTracker *Machine,
    1870             :                                           const Module *Context) {
    1871         260 :   Out << "!DITemplateValueParameter(";
    1872         260 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1873         260 :   if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
    1874          11 :     Printer.printTag(N);
    1875         780 :   Printer.printString("name", N->getName());
    1876         780 :   Printer.printMetadata("type", N->getRawType());
    1877         520 :   Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
    1878         260 :   Out << ")";
    1879         260 : }
    1880             : 
    1881         550 : static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
    1882             :                                   TypePrinting *TypePrinter,
    1883             :                                   SlotTracker *Machine, const Module *Context) {
    1884         550 :   Out << "!DIGlobalVariable(";
    1885         550 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1886        1650 :   Printer.printString("name", N->getName());
    1887        1100 :   Printer.printString("linkageName", N->getLinkageName());
    1888        1650 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1889        1650 :   Printer.printMetadata("file", N->getRawFile());
    1890        1100 :   Printer.printInt("line", N->getLine());
    1891        1650 :   Printer.printMetadata("type", N->getRawType());
    1892        1650 :   Printer.printBool("isLocal", N->isLocalToUnit());
    1893        1650 :   Printer.printBool("isDefinition", N->isDefinition());
    1894        1100 :   Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
    1895        1100 :   Printer.printInt("align", N->getAlignInBits());
    1896         550 :   Out << ")";
    1897         550 : }
    1898             : 
    1899        3204 : static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
    1900             :                                  TypePrinting *TypePrinter,
    1901             :                                  SlotTracker *Machine, const Module *Context) {
    1902        3204 :   Out << "!DILocalVariable(";
    1903        3204 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1904        9612 :   Printer.printString("name", N->getName());
    1905        6408 :   Printer.printInt("arg", N->getArg());
    1906        9612 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1907        9612 :   Printer.printMetadata("file", N->getRawFile());
    1908        6408 :   Printer.printInt("line", N->getLine());
    1909        9612 :   Printer.printMetadata("type", N->getRawType());
    1910        6408 :   Printer.printDIFlags("flags", N->getFlags());
    1911        6408 :   Printer.printInt("align", N->getAlignInBits());
    1912        3204 :   Out << ")";
    1913        3204 : }
    1914             : 
    1915        4313 : static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
    1916             :                               TypePrinting *TypePrinter, SlotTracker *Machine,
    1917             :                               const Module *Context) {
    1918        4313 :   Out << "!DIExpression(";
    1919        4313 :   FieldSeparator FS;
    1920        4313 :   if (N->isValid()) {
    1921       13573 :     for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
    1922        1292 :       auto OpStr = dwarf::OperationEncodingString(I->getOp());
    1923             :       assert(!OpStr.empty() && "Expected valid opcode");
    1924             : 
    1925         646 :       Out << FS << OpStr;
    1926        1684 :       for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
    1927         784 :         Out << FS << I->getArg(A);
    1928             :     }
    1929             :   } else {
    1930          23 :     for (const auto &I : N->getElements())
    1931          15 :       Out << FS << I;
    1932             :   }
    1933        4313 :   Out << ")";
    1934        4313 : }
    1935             : 
    1936         539 : static void writeDIGlobalVariableExpression(raw_ostream &Out,
    1937             :                                             const DIGlobalVariableExpression *N,
    1938             :                                             TypePrinting *TypePrinter,
    1939             :                                             SlotTracker *Machine,
    1940             :                                             const Module *Context) {
    1941         539 :   Out << "!DIGlobalVariableExpression(";
    1942         539 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1943        1078 :   Printer.printMetadata("var", N->getVariable());
    1944        1078 :   Printer.printMetadata("expr", N->getExpression());
    1945         539 :   Out << ")";
    1946         539 : }
    1947             : 
    1948          54 : static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
    1949             :                                 TypePrinting *TypePrinter, SlotTracker *Machine,
    1950             :                                 const Module *Context) {
    1951          54 :   Out << "!DIObjCProperty(";
    1952          54 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1953         108 :   Printer.printString("name", N->getName());
    1954         108 :   Printer.printMetadata("file", N->getRawFile());
    1955         108 :   Printer.printInt("line", N->getLine());
    1956         108 :   Printer.printString("setter", N->getSetterName());
    1957         108 :   Printer.printString("getter", N->getGetterName());
    1958         108 :   Printer.printInt("attributes", N->getAttributes());
    1959         108 :   Printer.printMetadata("type", N->getRawType());
    1960          54 :   Out << ")";
    1961          54 : }
    1962             : 
    1963          74 : static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
    1964             :                                   TypePrinting *TypePrinter,
    1965             :                                   SlotTracker *Machine, const Module *Context) {
    1966          74 :   Out << "!DIImportedEntity(";
    1967          74 :   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
    1968          74 :   Printer.printTag(N);
    1969         148 :   Printer.printString("name", N->getName());
    1970         148 :   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
    1971         148 :   Printer.printMetadata("entity", N->getRawEntity());
    1972         148 :   Printer.printMetadata("file", N->getRawFile());
    1973         148 :   Printer.printInt("line", N->getLine());
    1974          74 :   Out << ")";
    1975          74 : }
    1976             : 
    1977       65238 : static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
    1978             :                                     TypePrinting *TypePrinter,
    1979             :                                     SlotTracker *Machine,
    1980             :                                     const Module *Context) {
    1981       65238 :   if (Node->isDistinct())
    1982        9968 :     Out << "distinct ";
    1983       55270 :   else if (Node->isTemporary())
    1984           1 :     Out << "<temporary!> "; // Handle broken code.
    1985             : 
    1986      130476 :   switch (Node->getMetadataID()) {
    1987           0 :   default:
    1988           0 :     llvm_unreachable("Expected uniquable MDNode");
    1989             : #define HANDLE_MDNODE_LEAF(CLASS)                                              \
    1990             :   case Metadata::CLASS##Kind:                                                  \
    1991             :     write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context);       \
    1992             :     break;
    1993             : #include "llvm/IR/Metadata.def"
    1994             :   }
    1995       65238 : }
    1996             : 
    1997             : // Full implementation of printing a Value as an operand with support for
    1998             : // TypePrinting, etc.
    1999     3112263 : static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
    2000             :                                    TypePrinting *TypePrinter,
    2001             :                                    SlotTracker *Machine,
    2002             :                                    const Module *Context) {
    2003     3112263 :   if (V->hasName()) {
    2004     1695091 :     PrintLLVMName(Out, V);
    2005     1695091 :     return;
    2006             :   }
    2007             : 
    2008      822888 :   const Constant *CV = dyn_cast<Constant>(V);
    2009      822888 :   if (CV && !isa<GlobalValue>(CV)) {
    2010             :     assert(TypePrinter && "Constants require TypePrinting!");
    2011      810928 :     WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
    2012      810928 :     return;
    2013             :   }
    2014             : 
    2015        1702 :   if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
    2016        1702 :     Out << "asm ";
    2017        1702 :     if (IA->hasSideEffects())
    2018        1014 :       Out << "sideeffect ";
    2019        1702 :     if (IA->isAlignStack())
    2020          10 :       Out << "alignstack ";
    2021             :     // We don't emit the AD_ATT dialect as it's the assumed default.
    2022        1702 :     if (IA->getDialect() == InlineAsm::AD_Intel)
    2023         139 :       Out << "inteldialect ";
    2024        1702 :     Out << '"';
    2025        3404 :     PrintEscapedString(IA->getAsmString(), Out);
    2026        1702 :     Out << "\", \"";
    2027        3404 :     PrintEscapedString(IA->getConstraintString(), Out);
    2028             :     Out << '"';
    2029             :     return;
    2030             :   }
    2031             : 
    2032       10461 :   if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
    2033       10461 :     WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
    2034             :                            Context, /* FromValue */ true);
    2035       10461 :     return;
    2036             :   }
    2037             : 
    2038      594081 :   char Prefix = '%';
    2039             :   int Slot;
    2040             :   // If we have a SlotTracker, use it.
    2041      594081 :   if (Machine) {
    2042       11940 :     if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
    2043       11940 :       Slot = Machine->getGlobalSlot(GV);
    2044       11940 :       Prefix = '@';
    2045             :     } else {
    2046      581761 :       Slot = Machine->getLocalSlot(V);
    2047             : 
    2048             :       // If the local value didn't succeed, then we may be referring to a value
    2049             :       // from a different function.  Translate it, as this can happen when using
    2050             :       // address of blocks.
    2051      581761 :       if (Slot == -1)
    2052        1030 :         if ((Machine = createSlotTracker(V))) {
    2053        1030 :           Slot = Machine->getLocalSlot(V);
    2054        1030 :           delete Machine;
    2055             :         }
    2056             :     }
    2057         380 :   } else if ((Machine = createSlotTracker(V))) {
    2058             :     // Otherwise, create one to get the # and then destroy it.
    2059          20 :     if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
    2060          20 :       Slot = Machine->getGlobalSlot(GV);
    2061          20 :       Prefix = '@';
    2062             :     } else {
    2063         360 :       Slot = Machine->getLocalSlot(V);
    2064             :     }
    2065         380 :     delete Machine;
    2066         380 :     Machine = nullptr;
    2067             :   } else {
    2068             :     Slot = -1;
    2069             :   }
    2070             : 
    2071      594081 :   if (Slot != -1)
    2072     1188158 :     Out << Prefix << Slot;
    2073             :   else
    2074           2 :     Out << "<badref>";
    2075             : }
    2076             : 
    2077      188955 : static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
    2078             :                                    TypePrinting *TypePrinter,
    2079             :                                    SlotTracker *Machine, const Module *Context,
    2080             :                                    bool FromValue) {
    2081             :   // Write DIExpressions inline when used as a value. Improves readability of
    2082             :   // debug info intrinsics.
    2083        4264 :   if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
    2084        4264 :     writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
    2085        4264 :     return;
    2086             :   }
    2087             : 
    2088      153690 :   if (const MDNode *N = dyn_cast<MDNode>(MD)) {
    2089      307380 :     std::unique_ptr<SlotTracker> MachineStorage;
    2090      153690 :     if (!Machine) {
    2091           4 :       MachineStorage = make_unique<SlotTracker>(Context);
    2092           4 :       Machine = MachineStorage.get();
    2093             :     }
    2094      153690 :     int Slot = Machine->getMetadataSlot(N);
    2095      153690 :     if (Slot == -1)
    2096             :       // Give the pointer value instead of "badref", since this comes up all
    2097             :       // the time when debugging.
    2098           7 :       Out << "<" << N << ">";
    2099             :     else
    2100      153683 :       Out << '!' << Slot;
    2101             :     return;
    2102             :   }
    2103             : 
    2104       27325 :   if (const MDString *MDS = dyn_cast<MDString>(MD)) {
    2105       27325 :     Out << "!\"";
    2106       27325 :     PrintEscapedString(MDS->getString(), Out);
    2107             :     Out << '"';
    2108             :     return;
    2109             :   }
    2110             : 
    2111        3676 :   auto *V = cast<ValueAsMetadata>(MD);
    2112             :   assert(TypePrinter && "TypePrinter required for metadata values");
    2113             :   assert((FromValue || !isa<LocalAsMetadata>(V)) &&
    2114             :          "Unexpected function-local metadata outside of value argument");
    2115             : 
    2116        3676 :   TypePrinter->print(V->getValue()->getType(), Out);
    2117        3676 :   Out << ' ';
    2118        3676 :   WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
    2119             : }
    2120             : 
    2121             : namespace {
    2122             : 
    2123      148904 : class AssemblyWriter {
    2124             :   formatted_raw_ostream &Out;
    2125             :   const Module *TheModule;
    2126             :   std::unique_ptr<SlotTracker> SlotTrackerStorage;
    2127             :   SlotTracker &Machine;
    2128             :   TypePrinting TypePrinter;
    2129             :   AssemblyAnnotationWriter *AnnotationWriter;
    2130             :   SetVector<const Comdat *> Comdats;
    2131             :   bool IsForDebug;
    2132             :   bool ShouldPreserveUseListOrder;
    2133             :   UseListOrderStack UseListOrders;
    2134             :   SmallVector<StringRef, 8> MDNames;
    2135             :   /// Synchronization scope names registered with LLVMContext.
    2136             :   SmallVector<StringRef, 8> SSNs;
    2137             : 
    2138             : public:
    2139             :   /// Construct an AssemblyWriter with an external SlotTracker
    2140             :   AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
    2141             :                  AssemblyAnnotationWriter *AAW, bool IsForDebug,
    2142             :                  bool ShouldPreserveUseListOrder = false);
    2143             : 
    2144             :   void printMDNodeBody(const MDNode *MD);
    2145             :   void printNamedMDNode(const NamedMDNode *NMD);
    2146             : 
    2147             :   void printModule(const Module *M);
    2148             : 
    2149             :   void writeOperand(const Value *Op, bool PrintType);
    2150             :   void writeParamOperand(const Value *Operand, AttributeSet Attrs);
    2151             :   void writeOperandBundles(ImmutableCallSite CS);
    2152             :   void writeSyncScope(const LLVMContext &Context,
    2153             :                       SyncScope::ID SSID);
    2154             :   void writeAtomic(const LLVMContext &Context,
    2155             :                    AtomicOrdering Ordering,
    2156             :                    SyncScope::ID SSID);
    2157             :   void writeAtomicCmpXchg(const LLVMContext &Context,
    2158             :                           AtomicOrdering SuccessOrdering,
    2159             :                           AtomicOrdering FailureOrdering,
    2160             :                           SyncScope::ID SSID);
    2161             : 
    2162             :   void writeAllMDNodes();
    2163             :   void writeMDNode(unsigned Slot, const MDNode *Node);
    2164             :   void writeAllAttributeGroups();
    2165             : 
    2166             :   void printTypeIdentities();
    2167             :   void printGlobal(const GlobalVariable *GV);
    2168             :   void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
    2169             :   void printComdat(const Comdat *C);
    2170             :   void printFunction(const Function *F);
    2171             :   void printArgument(const Argument *FA, AttributeSet Attrs);
    2172             :   void printBasicBlock(const BasicBlock *BB);
    2173             :   void printInstructionLine(const Instruction &I);
    2174             :   void printInstruction(const Instruction &I);
    2175             : 
    2176             :   void printUseListOrder(const UseListOrder &Order);
    2177             :   void printUseLists(const Function *F);
    2178             : 
    2179             : private:
    2180             :   /// \brief Print out metadata attachments.
    2181             :   void printMetadataAttachments(
    2182             :       const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
    2183             :       StringRef Separator);
    2184             : 
    2185             :   // printInfoComment - Print a little comment after the instruction indicating
    2186             :   // which slot it occupies.
    2187             :   void printInfoComment(const Value &V);
    2188             : 
    2189             :   // printGCRelocateComment - print comment after call to the gc.relocate
    2190             :   // intrinsic indicating base and derived pointer names.
    2191             :   void printGCRelocateComment(const GCRelocateInst &Relocate);
    2192             : };
    2193             : 
    2194             : } // end anonymous namespace
    2195             : 
    2196       37226 : AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
    2197             :                                const Module *M, AssemblyAnnotationWriter *AAW,
    2198       37226 :                                bool IsForDebug, bool ShouldPreserveUseListOrder)
    2199             :     : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
    2200             :       IsForDebug(IsForDebug),
    2201      260582 :       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
    2202       37226 :   if (!TheModule)
    2203             :     return;
    2204       37188 :   TypePrinter.incorporateTypes(*TheModule);
    2205     1195306 :   for (const GlobalObject &GO : TheModule->global_objects())
    2206     1046554 :     if (const Comdat *C = GO.getComdat())
    2207       14611 :       Comdats.insert(C);
    2208             : }
    2209             : 
    2210     1963640 : void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
    2211     1963640 :   if (!Operand) {
    2212           0 :     Out << "<null operand!>";
    2213           0 :     return;
    2214             :   }
    2215     1963640 :   if (PrintType) {
    2216     1097046 :     TypePrinter.print(Operand->getType(), Out);
    2217     1097046 :     Out << ' ';
    2218             :   }
    2219     1963640 :   WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
    2220             : }
    2221             : 
    2222        3169 : void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
    2223             :                                     SyncScope::ID SSID) {
    2224        3169 :   switch (SSID) {
    2225             :   case SyncScope::System: {
    2226             :     break;
    2227             :   }
    2228         413 :   default: {
    2229         413 :     if (SSNs.empty())
    2230          37 :       Context.getSyncScopeNames(SSNs);
    2231             : 
    2232         413 :     Out << " syncscope(\"";
    2233         826 :     PrintEscapedString(SSNs[SSID], Out);
    2234         413 :     Out << "\")";
    2235         413 :     break;
    2236             :   }
    2237             :   }
    2238        3169 : }
    2239             : 
    2240        2517 : void AssemblyWriter::writeAtomic(const LLVMContext &Context,
    2241             :                                  AtomicOrdering Ordering,
    2242             :                                  SyncScope::ID SSID) {
    2243        2517 :   if (Ordering == AtomicOrdering::NotAtomic)
    2244             :     return;
    2245             : 
    2246        2517 :   writeSyncScope(Context, SSID);
    2247        5034 :   Out << " " << toIRString(Ordering);
    2248             : }
    2249             : 
    2250         652 : void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
    2251             :                                         AtomicOrdering SuccessOrdering,
    2252             :                                         AtomicOrdering FailureOrdering,
    2253             :                                         SyncScope::ID SSID) {
    2254             :   assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
    2255             :          FailureOrdering != AtomicOrdering::NotAtomic);
    2256             : 
    2257         652 :   writeSyncScope(Context, SSID);
    2258        1304 :   Out << " " << toIRString(SuccessOrdering);
    2259        1304 :   Out << " " << toIRString(FailureOrdering);
    2260         652 : }
    2261             : 
    2262      240255 : void AssemblyWriter::writeParamOperand(const Value *Operand,
    2263             :                                        AttributeSet Attrs) {
    2264      240255 :   if (!Operand) {
    2265           0 :     Out << "<null operand!>";
    2266           0 :     return;
    2267             :   }
    2268             : 
    2269             :   // Print the type
    2270      240255 :   TypePrinter.print(Operand->getType(), Out);
    2271             :   // Print parameter attributes list
    2272      240255 :   if (Attrs.hasAttributes())
    2273       27552 :     Out << ' ' << Attrs.getAsString();
    2274      480510 :   Out << ' ';
    2275             :   // Print the operand
    2276      240255 :   WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
    2277             : }
    2278             : 
    2279      118294 : void AssemblyWriter::writeOperandBundles(ImmutableCallSite CS) {
    2280      118294 :   if (!CS.hasOperandBundles())
    2281             :     return;
    2282             : 
    2283         757 :   Out << " [ ";
    2284             : 
    2285         757 :   bool FirstBundle = true;
    2286        1584 :   for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
    2287         827 :     OperandBundleUse BU = CS.getOperandBundleAt(i);
    2288             : 
    2289         827 :     if (!FirstBundle)
    2290          70 :       Out << ", ";
    2291         827 :     FirstBundle = false;
    2292             : 
    2293        1654 :     Out << '"';
    2294        1654 :     PrintEscapedString(BU.getTagName(), Out);
    2295        1654 :     Out << '"';
    2296             : 
    2297        1654 :     Out << '(';
    2298             : 
    2299         827 :     bool FirstInput = true;
    2300        2519 :     for (const auto &Input : BU.Inputs) {
    2301         865 :       if (!FirstInput)
    2302         265 :         Out << ", ";
    2303         865 :       FirstInput = false;
    2304             : 
    2305         865 :       TypePrinter.print(Input->getType(), Out);
    2306         865 :       Out << " ";
    2307         865 :       WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
    2308             :     }
    2309             : 
    2310        1654 :     Out << ')';
    2311             :   }
    2312             : 
    2313         757 :   Out << " ]";
    2314             : }
    2315             : 
    2316       12402 : void AssemblyWriter::printModule(const Module *M) {
    2317       12402 :   Machine.initialize();
    2318             : 
    2319       12402 :   if (ShouldPreserveUseListOrder)
    2320        1484 :     UseListOrders = predictUseListOrder(M);
    2321             : 
    2322       24804 :   if (!M->getModuleIdentifier().empty() &&
    2323             :       // Don't print the ID if it will start a new line (which would
    2324             :       // require a comment char before it).
    2325       12402 :       M->getModuleIdentifier().find('\n') == std::string::npos)
    2326       24804 :     Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
    2327             : 
    2328       12402 :   if (!M->getSourceFileName().empty()) {
    2329       12402 :     Out << "source_filename = \"";
    2330       37206 :     PrintEscapedString(M->getSourceFileName(), Out);
    2331       12402 :     Out << "\"\n";
    2332             :   }
    2333             : 
    2334       12402 :   const std::string &DL = M->getDataLayoutStr();
    2335       12402 :   if (!DL.empty())
    2336       16586 :     Out << "target datalayout = \"" << DL << "\"\n";
    2337       12402 :   if (!M->getTargetTriple().empty())
    2338       15072 :     Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
    2339             : 
    2340       12402 :   if (!M->getModuleInlineAsm().empty()) {
    2341         200 :     Out << '\n';
    2342             : 
    2343             :     // Split the string into lines, to make it easier to read the .ll file.
    2344         100 :     StringRef Asm = M->getModuleInlineAsm();
    2345             :     do {
    2346             :       StringRef Front;
    2347         969 :       std::tie(Front, Asm) = Asm.split('\n');
    2348             : 
    2349             :       // We found a newline, print the portion of the asm string from the
    2350             :       // last newline up to this newline.
    2351         323 :       Out << "module asm \"";
    2352         323 :       PrintEscapedString(Front, Out);
    2353         323 :       Out << "\"\n";
    2354         323 :     } while (!Asm.empty());
    2355             :   }
    2356             : 
    2357       12402 :   printTypeIdentities();
    2358             : 
    2359             :   // Output all comdats.
    2360       24804 :   if (!Comdats.empty())
    2361        1276 :     Out << '\n';
    2362       63134 :   for (const Comdat *C : Comdats) {
    2363       27052 :     printComdat(C);
    2364       27052 :     if (C != Comdats.back())
    2365       12250 :       Out << '\n';
    2366             :   }
    2367             : 
    2368             :   // Output all globals.
    2369       12402 :   if (!M->global_empty()) Out << '\n';
    2370       66292 :   for (const GlobalVariable &GV : M->globals()) {
    2371      107780 :     printGlobal(&GV); Out << '\n';
    2372             :   }
    2373             : 
    2374             :   // Output all aliases.
    2375       12402 :   if (!M->alias_empty()) Out << "\n";
    2376       13453 :   for (const GlobalAlias &GA : M->aliases())
    2377        1051 :     printIndirectSymbol(&GA);
    2378             : 
    2379             :   // Output all ifuncs.
    2380       12402 :   if (!M->ifunc_empty()) Out << "\n";
    2381       12445 :   for (const GlobalIFunc &GI : M->ifuncs())
    2382          43 :     printIndirectSymbol(&GI);
    2383             : 
    2384             :   // Output global use-lists.
    2385       12402 :   printUseLists(nullptr);
    2386             : 
    2387             :   // Output all of the functions.
    2388      182305 :   for (const Function &F : *M)
    2389      145099 :     printFunction(&F);
    2390             :   assert(UseListOrders.empty() && "All use-lists should have been consumed");
    2391             : 
    2392             :   // Output all attribute groups.
    2393       24804 :   if (!Machine.as_empty()) {
    2394       16356 :     Out << '\n';
    2395        8178 :     writeAllAttributeGroups();
    2396             :   }
    2397             : 
    2398             :   // Output named metadata.
    2399       12402 :   if (!M->named_metadata_empty()) Out << '\n';
    2400             : 
    2401       25072 :   for (const NamedMDNode &Node : M->named_metadata())
    2402       12670 :     printNamedMDNode(&Node);
    2403             : 
    2404             :   // Output metadata.
    2405       24804 :   if (!Machine.mdn_empty()) {
    2406       13836 :     Out << '\n';
    2407        6918 :     writeAllMDNodes();
    2408             :   }
    2409       12402 : }
    2410             : 
    2411       89465 : static void printMetadataIdentifier(StringRef Name,
    2412             :                                     formatted_raw_ostream &Out) {
    2413       89465 :   if (Name.empty()) {
    2414           1 :     Out << "<empty name> ";
    2415             :   } else {
    2416      178984 :     if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
    2417       89520 :         Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
    2418       89438 :       Out << Name[0];
    2419             :     else
    2420         182 :       Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
    2421      677931 :     for (unsigned i = 1, e = Name.size(); i != e; ++i) {
    2422     1176934 :       unsigned char C = Name[i];
    2423      588467 :       if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
    2424       45556 :           C == '.' || C == '_')
    2425      588462 :         Out << C;
    2426             :       else
    2427          25 :         Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
    2428             :     }
    2429             :   }
    2430       89465 : }
    2431             : 
    2432       12681 : void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
    2433       25362 :   Out << '!';
    2434       12681 :   printMetadataIdentifier(NMD->getName(), Out);
    2435       12681 :   Out << " = !{";
    2436       33508 :   for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
    2437       20827 :     if (i)
    2438        8208 :       Out << ", ";
    2439             : 
    2440             :     // Write DIExpressions inline.
    2441             :     // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
    2442       20827 :     MDNode *Op = NMD->getOperand(i);
    2443          98 :     if (auto *Expr = dyn_cast<DIExpression>(Op)) {
    2444          49 :       writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
    2445             :       continue;
    2446             :     }
    2447             : 
    2448       20778 :     int Slot = Machine.getMetadataSlot(Op);
    2449       20778 :     if (Slot == -1)
    2450           0 :       Out << "<badref>";
    2451             :     else
    2452       41556 :       Out << '!' << Slot;
    2453             :   }
    2454       12681 :   Out << "}\n";
    2455       12681 : }
    2456             : 
    2457      200419 : static const char *getLinkagePrintName(GlobalValue::LinkageTypes LT) {
    2458      200419 :   switch (LT) {
    2459             :   case GlobalValue::ExternalLinkage:
    2460             :     return "";
    2461       18464 :   case GlobalValue::PrivateLinkage:
    2462       18464 :     return "private ";
    2463       16055 :   case GlobalValue::InternalLinkage:
    2464       16055 :     return "internal ";
    2465         364 :   case GlobalValue::LinkOnceAnyLinkage:
    2466         364 :     return "linkonce ";
    2467       14415 :   case GlobalValue::LinkOnceODRLinkage:
    2468       14415 :     return "linkonce_odr ";
    2469         621 :   case GlobalValue::WeakAnyLinkage:
    2470         621 :     return "weak ";
    2471        2542 :   case GlobalValue::WeakODRLinkage:
    2472        2542 :     return "weak_odr ";
    2473        3735 :   case GlobalValue::CommonLinkage:
    2474        3735 :     return "common ";
    2475        1766 :   case GlobalValue::AppendingLinkage:
    2476        1766 :     return "appending ";
    2477         470 :   case GlobalValue::ExternalWeakLinkage:
    2478         470 :     return "extern_weak ";
    2479         572 :   case GlobalValue::AvailableExternallyLinkage:
    2480         572 :     return "available_externally ";
    2481             :   }
    2482           0 :   llvm_unreachable("invalid linkage");
    2483             : }
    2484             : 
    2485      200419 : static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
    2486             :                             formatted_raw_ostream &Out) {
    2487      200419 :   switch (Vis) {
    2488             :   case GlobalValue::DefaultVisibility: break;
    2489        2742 :   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
    2490          56 :   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
    2491             :   }
    2492      200419 : }
    2493             : 
    2494      200419 : static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
    2495             :                                  formatted_raw_ostream &Out) {
    2496      200419 :   switch (SCT) {
    2497             :   case GlobalValue::DefaultStorageClass: break;
    2498        1645 :   case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
    2499        2542 :   case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
    2500             :   }
    2501      200419 : }
    2502             : 
    2503       54993 : static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM,
    2504             :                                   formatted_raw_ostream &Out) {
    2505       54993 :   switch (TLM) {
    2506             :     case GlobalVariable::NotThreadLocal:
    2507             :       break;
    2508         316 :     case GlobalVariable::GeneralDynamicTLSModel:
    2509         316 :       Out << "thread_local ";
    2510         316 :       break;
    2511          29 :     case GlobalVariable::LocalDynamicTLSModel:
    2512          29 :       Out << "thread_local(localdynamic) ";
    2513          29 :       break;
    2514         667 :     case GlobalVariable::InitialExecTLSModel:
    2515         667 :       Out << "thread_local(initialexec) ";
    2516         667 :       break;
    2517          28 :     case GlobalVariable::LocalExecTLSModel:
    2518          28 :       Out << "thread_local(localexec) ";
    2519          28 :       break;
    2520             :   }
    2521       54993 : }
    2522             : 
    2523             : static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) {
    2524      200419 :   switch (UA) {
    2525             :   case GlobalVariable::UnnamedAddr::None:
    2526             :     return "";
    2527        6798 :   case GlobalVariable::UnnamedAddr::Local:
    2528        6798 :     return "local_unnamed_addr";
    2529       28659 :   case GlobalVariable::UnnamedAddr::Global:
    2530       28659 :     return "unnamed_addr";
    2531             :   }
    2532           0 :   llvm_unreachable("Unknown UnnamedAddr");
    2533             : }
    2534             : 
    2535      199325 : static void maybePrintComdat(formatted_raw_ostream &Out,
    2536             :                              const GlobalObject &GO) {
    2537      199325 :   const Comdat *C = GO.getComdat();
    2538      199325 :   if (!C)
    2539             :     return;
    2540             : 
    2541       14611 :   if (isa<GlobalVariable>(GO))
    2542        5542 :     Out << ',';
    2543       14611 :   Out << " comdat";
    2544             : 
    2545       14611 :   if (GO.getName() == C->getName())
    2546             :     return;
    2547             : 
    2548        2712 :   Out << '(';
    2549        1356 :   PrintLLVMName(Out, C->getName(), ComdatPrefix);
    2550        1356 :   Out << ')';
    2551             : }
    2552             : 
    2553       53899 : void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
    2554       53899 :   if (GV->isMaterializable())
    2555           0 :     Out << "; Materializable\n";
    2556             : 
    2557       53899 :   WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
    2558       53899 :   Out << " = ";
    2559             : 
    2560       60255 :   if (!GV->hasInitializer() && GV->hasExternalLinkage())
    2561        6272 :     Out << "external ";
    2562             : 
    2563      107798 :   Out << getLinkagePrintName(GV->getLinkage());
    2564      107798 :   PrintVisibility(GV->getVisibility(), Out);
    2565      107798 :   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
    2566      107798 :   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
    2567      161697 :   StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
    2568       53899 :   if (!UA.empty())
    2569       18170 :       Out << UA << ' ';
    2570             : 
    2571      161697 :   if (unsigned AddressSpace = GV->getType()->getAddressSpace())
    2572        1892 :     Out << "addrspace(" << AddressSpace << ") ";
    2573       53899 :   if (GV->isExternallyInitialized()) Out << "externally_initialized ";
    2574      107798 :   Out << (GV->isConstant() ? "constant " : "global ");
    2575       53899 :   TypePrinter.print(GV->getValueType(), Out);
    2576             : 
    2577       53899 :   if (GV->hasInitializer()) {
    2578       95086 :     Out << ' ';
    2579       47543 :     writeOperand(GV->getInitializer(), false);
    2580             :   }
    2581             : 
    2582      107798 :   if (GV->hasSection()) {
    2583       11239 :     Out << ", section \"";
    2584       22478 :     PrintEscapedString(GV->getSection(), Out);
    2585       11239 :     Out << '"';
    2586             :   }
    2587       53899 :   maybePrintComdat(Out, *GV);
    2588      107798 :   if (GV->getAlignment())
    2589       61338 :     Out << ", align " << GV->getAlignment();
    2590             : 
    2591      107798 :   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
    2592       53899 :   GV->getAllMetadata(MDs);
    2593       53899 :   printMetadataAttachments(MDs, ", ");
    2594             : 
    2595       53899 :   auto Attrs = GV->getAttributes();
    2596       53899 :   if (Attrs.hasAttributes())
    2597          33 :     Out << " #" << Machine.getAttributeGroupSlot(Attrs);
    2598             : 
    2599       53899 :   printInfoComment(*GV);
    2600       53899 : }
    2601             : 
    2602        1094 : void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
    2603        1094 :   if (GIS->isMaterializable())
    2604           0 :     Out << "; Materializable\n";
    2605             : 
    2606        1094 :   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
    2607        1094 :   Out << " = ";
    2608             : 
    2609        2188 :   Out << getLinkagePrintName(GIS->getLinkage());
    2610        2188 :   PrintVisibility(GIS->getVisibility(), Out);
    2611        2188 :   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
    2612        2188 :   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
    2613        3282 :   StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
    2614        1094 :   if (!UA.empty())
    2615         185 :       Out << UA << ' ';
    2616             : 
    2617        2188 :   if (isa<GlobalAlias>(GIS))
    2618        1051 :     Out << "alias ";
    2619          86 :   else if (isa<GlobalIFunc>(GIS))
    2620          43 :     Out << "ifunc ";
    2621             :   else
    2622           0 :     llvm_unreachable("Not an alias or ifunc!");
    2623             : 
    2624        1094 :   TypePrinter.print(GIS->getValueType(), Out);
    2625             : 
    2626        1094 :   Out << ", ";
    2627             : 
    2628        2188 :   const Constant *IS = GIS->getIndirectSymbol();
    2629             : 
    2630             :   if (!IS) {
    2631           0 :     TypePrinter.print(GIS->getType(), Out);
    2632           0 :     Out << " <<NULL ALIASEE>>";
    2633             :   } else {
    2634        2188 :     writeOperand(IS, !isa<ConstantExpr>(IS));
    2635             :   }
    2636             : 
    2637        1094 :   printInfoComment(*GIS);
    2638        2188 :   Out << '\n';
    2639        1094 : }
    2640             : 
    2641             : void AssemblyWriter::printComdat(const Comdat *C) {
    2642       13526 :   C->print(Out);
    2643             : }
    2644             : 
    2645       12402 : void AssemblyWriter::printTypeIdentities() {
    2646       36773 :   if (TypePrinter.NumberedTypes.empty() &&
    2647       23938 :       TypePrinter.NamedTypes.empty())
    2648        8676 :     return;
    2649             : 
    2650        7452 :   Out << '\n';
    2651             : 
    2652             :   // We know all the numbers that each type is used and we know that it is a
    2653             :   // dense assignment.  Convert the map to an index table.
    2654       14904 :   std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
    2655             :   for (DenseMap<StructType*, unsigned>::iterator I =
    2656        7452 :        TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
    2657        4630 :        I != E; ++I) {
    2658             :     assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?");
    2659        1808 :     NumberedTypes[I->second] = I->first;
    2660             :   }
    2661             : 
    2662             :   // Emit all numbered types.
    2663        8356 :   for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
    2664        2712 :     Out << '%' << i << " = type ";
    2665             : 
    2666             :     // Make sure we print out at least one level of the type structure, so
    2667             :     // that we do not get %2 = type %2
    2668        1808 :     TypePrinter.printStructBody(NumberedTypes[i], Out);
    2669        1808 :     Out << '\n';
    2670             :   }
    2671             : 
    2672       28559 :   for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) {
    2673       42214 :     PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix);
    2674       21107 :     Out << " = type ";
    2675             : 
    2676             :     // Make sure we print out at least one level of the type structure, so
    2677             :     // that we do not get %FILE = type %FILE
    2678       42214 :     TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
    2679       42214 :     Out << '\n';
    2680             :   }
    2681             : }
    2682             : 
    2683             : /// printFunction - Print all aspects of a function.
    2684      145426 : void AssemblyWriter::printFunction(const Function *F) {
    2685             :   // Print out the return type and name.
    2686      290852 :   Out << '\n';
    2687             : 
    2688      145426 :   if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
    2689             : 
    2690      145426 :   if (F->isMaterializable())
    2691           6 :     Out << "; Materializable\n";
    2692             : 
    2693      145426 :   const AttributeList &Attrs = F->getAttributes();
    2694      145426 :   if (Attrs.hasAttributes(AttributeList::FunctionIndex)) {
    2695      102995 :     AttributeSet AS = Attrs.getFnAttributes();
    2696      205990 :     std::string AttrStr;
    2697             : 
    2698     1241995 :     for (const Attribute &Attr : AS) {
    2699     1139000 :       if (!Attr.isStringAttribute()) {
    2700      221585 :         if (!AttrStr.empty()) AttrStr += ' ';
    2701      664755 :         AttrStr += Attr.getAsString();
    2702             :       }
    2703             :     }
    2704             : 
    2705      102995 :     if (!AttrStr.empty())
    2706      188904 :       Out << "; Function Attrs: " << AttrStr << '\n';
    2707             :   }
    2708             : 
    2709      290852 :   Machine.incorporateFunction(F);
    2710             : 
    2711      145426 :   if (F->isDeclaration()) {
    2712       51387 :     Out << "declare";
    2713      102774 :     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
    2714       51387 :     F->getAllMetadata(MDs);
    2715       51387 :     printMetadataAttachments(MDs, " ");
    2716      102774 :     Out << ' ';
    2717             :   } else
    2718       94039 :     Out << "define ";
    2719             : 
    2720      290852 :   Out << getLinkagePrintName(F->getLinkage());
    2721      290852 :   PrintVisibility(F->getVisibility(), Out);
    2722      290852 :   PrintDLLStorageClass(F->getDLLStorageClass(), Out);
    2723             : 
    2724             :   // Print the calling convention.
    2725      145426 :   if (F->getCallingConv() != CallingConv::C) {
    2726       15954 :     PrintCallingConv(F->getCallingConv(), Out);
    2727        7977 :     Out << " ";
    2728             :   }
    2729             : 
    2730      145426 :   FunctionType *FT = F->getFunctionType();
    2731      145426 :   if (Attrs.hasAttributes(AttributeList::ReturnIndex))
    2732       13480 :     Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
    2733      290852 :   TypePrinter.print(F->getReturnType(), Out);
    2734      290852 :   Out << ' ';
    2735      145426 :   WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
    2736      290852 :   Out << '(';
    2737             : 
    2738             :   // Loop over the arguments, printing them...
    2739      145426 :   if (F->isDeclaration() && !IsForDebug) {
    2740             :     // We're only interested in the type here - don't print argument names.
    2741      341491 :     for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
    2742             :       // Insert commas as we go... the first arg doesn't get a comma
    2743       93665 :       if (I)
    2744       49641 :         Out << ", ";
    2745             :       // Output type...
    2746      187330 :       TypePrinter.print(FT->getParamType(I), Out);
    2747             : 
    2748       93665 :       AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
    2749       93665 :       if (ArgAttrs.hasAttributes())
    2750       26012 :         Out << ' ' << ArgAttrs.getAsString();
    2751             :     }
    2752             :   } else {
    2753             :     // The arguments are meaningful here, print them in detail.
    2754      442384 :     for (const Argument &Arg : F->args()) {
    2755             :       // Insert commas as we go... the first arg doesn't get a comma
    2756      127153 :       if (Arg.getArgNo() != 0)
    2757       57611 :         Out << ", ";
    2758      127153 :       printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
    2759             :     }
    2760             :   }
    2761             : 
    2762             :   // Finish printing arguments...
    2763      145426 :   if (FT->isVarArg()) {
    2764        3031 :     if (FT->getNumParams()) Out << ", ";
    2765        3031 :     Out << "...";  // Output varargs portion of signature!
    2766             :   }
    2767      290852 :   Out << ')';
    2768      436278 :   StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
    2769      145426 :   if (!UA.empty())
    2770       34204 :     Out << ' ' << UA;
    2771      145426 :   if (Attrs.hasAttributes(AttributeList::FunctionIndex))
    2772      102995 :     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
    2773      290852 :   if (F->hasSection()) {
    2774        1125 :     Out << " section \"";
    2775        2250 :     PrintEscapedString(F->getSection(), Out);
    2776        1125 :     Out << '"';
    2777             :   }
    2778      145426 :   maybePrintComdat(Out, *F);
    2779      290852 :   if (F->getAlignment())
    2780       23606 :     Out << " align " << F->getAlignment();
    2781      145426 :   if (F->hasGC())
    2782         488 :     Out << " gc \"" << F->getGC() << '"';
    2783      145426 :   if (F->hasPrefixData()) {
    2784          26 :     Out << " prefix ";
    2785          26 :     writeOperand(F->getPrefixData(), true);
    2786             :   }
    2787      145426 :   if (F->hasPrologueData()) {
    2788         215 :     Out << " prologue ";
    2789         215 :     writeOperand(F->getPrologueData(), true);
    2790             :   }
    2791      145426 :   if (F->hasPersonalityFn()) {
    2792        1291 :     Out << " personality ";
    2793        1291 :     writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
    2794             :   }
    2795             : 
    2796      145426 :   if (F->isDeclaration()) {
    2797       51387 :     Out << '\n';
    2798             :   } else {
    2799      188078 :     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
    2800       94039 :     F->getAllMetadata(MDs);
    2801       94039 :     printMetadataAttachments(MDs, " ");
    2802             : 
    2803       94039 :     Out << " {";
    2804             :     // Output all of the function's basic blocks.
    2805      457172 :     for (const BasicBlock &BB : *F)
    2806      175055 :       printBasicBlock(&BB);
    2807             : 
    2808             :     // Output the function's use-lists.
    2809       94039 :     printUseLists(F);
    2810             : 
    2811       94039 :     Out << "}\n";
    2812             :   }
    2813             : 
    2814      145426 :   Machine.purgeFunction();
    2815      145426 : }
    2816             : 
    2817             : /// printArgument - This member is called for every argument that is passed into
    2818             : /// the function.  Simply print it out
    2819      127153 : void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
    2820             :   // Output type...
    2821      127153 :   TypePrinter.print(Arg->getType(), Out);
    2822             : 
    2823             :   // Output parameter attributes list
    2824      127153 :   if (Attrs.hasAttributes())
    2825       90844 :     Out << ' ' << Attrs.getAsString();
    2826             : 
    2827             :   // Output name, if available...
    2828      254306 :   if (Arg->hasName()) {
    2829      239034 :     Out << ' ';
    2830      119517 :     PrintLLVMName(Out, Arg);
    2831             :   }
    2832      127153 : }
    2833             : 
    2834             : /// printBasicBlock - This member is called for each basic block in a method.
    2835      175077 : void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
    2836      350154 :   if (BB->hasName()) {              // Print out the label if it exists...
    2837       52925 :     Out << "\n";
    2838      105850 :     PrintLLVMName(Out, BB->getName(), LabelPrefix);
    2839       52925 :     Out << ':';
    2840      244304 :   } else if (!BB->use_empty()) {      // Don't print block # of no uses...
    2841       39569 :     Out << "\n; <label>:";
    2842       39569 :     int Slot = Machine.getLocalSlot(BB);
    2843       39569 :     if (Slot != -1)
    2844       79138 :       Out << Slot << ":";
    2845             :     else
    2846           0 :       Out << "<badref>";
    2847             :   }
    2848             : 
    2849      175077 :   if (!BB->getParent()) {
    2850           0 :     Out.PadToColumn(50);
    2851           0 :     Out << "; Error: Block without parent!";
    2852      350154 :   } else if (BB != &BB->getParent()->getEntryBlock()) {  // Not the entry block?
    2853             :     // Output predecessors for the block.
    2854       81040 :     Out.PadToColumn(50);
    2855       81040 :     Out << ";";
    2856      162080 :     const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
    2857             : 
    2858       81040 :     if (PI == PE) {
    2859         763 :       Out << " No predecessors!";
    2860             :     } else {
    2861       80277 :       Out << " preds = ";
    2862       80277 :       writeOperand(*PI, false);
    2863      112663 :       for (++PI; PI != PE; ++PI) {
    2864       32386 :         Out << ", ";
    2865       32386 :         writeOperand(*PI, false);
    2866             :       }
    2867             :     }
    2868             :   }
    2869             : 
    2870      175077 :   Out << "\n";
    2871             : 
    2872      175077 :   if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
    2873             : 
    2874             :   // Output all of the instructions in the basic block...
    2875     1860241 :   for (const Instruction &I : *BB) {
    2876     1335010 :     printInstructionLine(I);
    2877             :   }
    2878             : 
    2879      175077 :   if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
    2880      175077 : }
    2881             : 
    2882             : /// printInstructionLine - Print an instruction and a newline character.
    2883     1335010 : void AssemblyWriter::printInstructionLine(const Instruction &I) {
    2884     1335010 :   printInstruction(I);
    2885     2670020 :   Out << '\n';
    2886     1335010 : }
    2887             : 
    2888             : /// printGCRelocateComment - print comment after call to the gc.relocate
    2889             : /// intrinsic indicating base and derived pointer names.
    2890         242 : void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
    2891         242 :   Out << " ; (";
    2892         242 :   writeOperand(Relocate.getBasePtr(), false);
    2893         242 :   Out << ", ";
    2894         242 :   writeOperand(Relocate.getDerivedPtr(), false);
    2895         242 :   Out << ")";
    2896         242 : }
    2897             : 
    2898             : /// printInfoComment - Print a little comment after the instruction indicating
    2899             : /// which slot it occupies.
    2900     1414458 : void AssemblyWriter::printInfoComment(const Value &V) {
    2901         242 :   if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
    2902         242 :     printGCRelocateComment(*Relocate);
    2903             : 
    2904     1414458 :   if (AnnotationWriter)
    2905        1136 :     AnnotationWriter->printInfoComment(V, Out);
    2906     1414458 : }
    2907             : 
    2908             : // This member is called for each Instruction in a function..
    2909     1359465 : void AssemblyWriter::printInstruction(const Instruction &I) {
    2910     1359465 :   if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
    2911             : 
    2912             :   // Print out indentation for an instruction.
    2913     1359465 :   Out << "  ";
    2914             : 
    2915             :   // Print out name if it exists...
    2916     2718930 :   if (I.hasName()) {
    2917      454240 :     PrintLLVMName(Out, &I);
    2918      454240 :     Out << " = ";
    2919     1810450 :   } else if (!I.getType()->isVoidTy()) {
    2920             :     // Print out the def slot taken.
    2921      431455 :     int SlotNum = Machine.getLocalSlot(&I);
    2922      431455 :     if (SlotNum == -1)
    2923          38 :       Out << "<badref> = ";
    2924             :     else
    2925     1294251 :       Out << '%' << SlotNum << " = ";
    2926             :   }
    2927             : 
    2928      115937 :   if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
    2929      115937 :     if (CI->isMustTailCall())
    2930         100 :       Out << "musttail ";
    2931      115837 :     else if (CI->isTailCall())
    2932        8182 :       Out << "tail ";
    2933      107655 :     else if (CI->isNoTailCall())
    2934          44 :       Out << "notail ";
    2935             :   }
    2936             : 
    2937             :   // Print out the opcode...
    2938     2718930 :   Out << I.getOpcodeName();
    2939             : 
    2940             :   // If this is an atomic load or store, print out the atomic marker.
    2941     2963923 :   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isAtomic()) ||
    2942     1589431 :       (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
    2943        1593 :     Out << " atomic";
    2944             : 
    2945     1360769 :   if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
    2946          63 :     Out << " weak";
    2947             : 
    2948             :   // If this is a volatile operation, print out the volatile marker.
    2949     3201828 :   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
    2950     3156682 :       (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
    2951     4049410 :       (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
    2952     1345674 :       (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
    2953       15231 :     Out << " volatile";
    2954             : 
    2955             :   // Print out optimization information.
    2956     1359465 :   WriteOptimizationInfo(Out, &I);
    2957             : 
    2958             :   // Print out the compare instruction predicates
    2959       37668 :   if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
    2960      113004 :     Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
    2961             : 
    2962             :   // Print out the atomicrmw operation
    2963         703 :   if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
    2964         703 :     writeAtomicRMWOperation(Out, RMWI->getOperation());
    2965             : 
    2966             :   // Print out the type of the operands...
    2967     4028231 :   const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
    2968             : 
    2969             :   // Special case conditional branches to swizzle the condition out to the front
    2970     1505733 :   if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
    2971       30892 :     const BranchInst &BI(cast<BranchInst>(I));
    2972       61784 :     Out << ' ';
    2973       30892 :     writeOperand(BI.getCondition(), true);
    2974       30892 :     Out << ", ";
    2975       30892 :     writeOperand(BI.getSuccessor(0), true);
    2976       30892 :     Out << ", ";
    2977       30892 :     writeOperand(BI.getSuccessor(1), true);
    2978             : 
    2979     1328573 :   } else if (isa<SwitchInst>(I)) {
    2980         883 :     const SwitchInst& SI(cast<SwitchInst>(I));
    2981             :     // Special case switch instruction to get formatting nice and correct.
    2982        1766 :     Out << ' ';
    2983         883 :     writeOperand(SI.getCondition(), true);
    2984         883 :     Out << ", ";
    2985         883 :     writeOperand(SI.getDefaultDest(), true);
    2986         883 :     Out << " [";
    2987        3954 :     for (auto Case : SI.cases()) {
    2988        2188 :       Out << "\n    ";
    2989        2188 :       writeOperand(Case.getCaseValue(), true);
    2990        2188 :       Out << ", ";
    2991        2188 :       writeOperand(Case.getCaseSuccessor(), true);
    2992             :     }
    2993         883 :     Out << "\n  ]";
    2994     1327690 :   } else if (isa<IndirectBrInst>(I)) {
    2995             :     // Special case indirectbr instruction to get formatting nice and correct.
    2996         388 :     Out << ' ';
    2997         194 :     writeOperand(Operand, true);
    2998         194 :     Out << ", [";
    2999             : 
    3000         936 :     for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
    3001         548 :       if (i != 1)
    3002         358 :         Out << ", ";
    3003        1096 :       writeOperand(I.getOperand(i), true);
    3004             :     }
    3005         194 :     Out << ']';
    3006     1327496 :   } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
    3007       31608 :     Out << ' ';
    3008       15804 :     TypePrinter.print(I.getType(), Out);
    3009       31608 :     Out << ' ';
    3010             : 
    3011       63417 :     for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
    3012       31809 :       if (op) Out << ", ";
    3013       31809 :       Out << "[ ";
    3014       31809 :       writeOperand(PN->getIncomingValue(op), false); Out << ", ";
    3015       31809 :       writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
    3016             :     }
    3017     1311692 :   } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
    3018       14040 :     Out << ' ';
    3019       14040 :     writeOperand(I.getOperand(0), true);
    3020       21113 :     for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
    3021       14146 :       Out << ", " << *i;
    3022     1304672 :   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
    3023        4712 :     Out << ' ';
    3024        4712 :     writeOperand(I.getOperand(0), true); Out << ", ";
    3025        4712 :     writeOperand(I.getOperand(1), true);
    3026        7105 :     for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
    3027        4786 :       Out << ", " << *i;
    3028     1302316 :   } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
    3029        2660 :     Out << ' ';
    3030        1330 :     TypePrinter.print(I.getType(), Out);
    3031        1931 :     if (LPI->isCleanup() || LPI->getNumClauses() != 0)
    3032        1330 :       Out << '\n';
    3033             : 
    3034        1330 :     if (LPI->isCleanup())
    3035         729 :       Out << "          cleanup";
    3036             : 
    3037        3379 :     for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
    3038        1375 :       if (i != 0 || LPI->isCleanup()) Out << "\n";
    3039         719 :       if (LPI->isCatch(i))
    3040         663 :         Out << "          catch ";
    3041             :       else
    3042          56 :         Out << "          filter ";
    3043             : 
    3044         719 :       writeOperand(LPI->getClause(i), true);
    3045             :     }
    3046     1300986 :   } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
    3047         222 :     Out << " within ";
    3048         222 :     writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
    3049         222 :     Out << " [";
    3050         222 :     unsigned Op = 0;
    3051         684 :     for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
    3052         231 :       if (Op > 0)
    3053           9 :         Out << ", ";
    3054         231 :       writeOperand(PadBB, /*PrintType=*/true);
    3055         231 :       ++Op;
    3056             :     }
    3057         222 :     Out << "] unwind ";
    3058          59 :     if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
    3059          59 :       writeOperand(UnwindDest, /*PrintType=*/true);
    3060             :     else
    3061         163 :       Out << "to caller";
    3062     1300764 :   } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
    3063         563 :     Out << " within ";
    3064         563 :     writeOperand(FPI->getParentPad(), /*PrintType=*/false);
    3065         563 :     Out << " [";
    3066        1425 :     for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
    3067             :          ++Op) {
    3068         299 :       if (Op > 0)
    3069         147 :         Out << ", ";
    3070         299 :       writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
    3071             :     }
    3072         563 :     Out << ']';
    3073     1300201 :   } else if (isa<ReturnInst>(I) && !Operand) {
    3074       46109 :     Out << " void";
    3075     1254092 :   } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
    3076         148 :     Out << " from ";
    3077         148 :     writeOperand(CRI->getOperand(0), /*PrintType=*/false);
    3078             : 
    3079         148 :     Out << " to ";
    3080         148 :     writeOperand(CRI->getOperand(1), /*PrintType=*/true);
    3081     1253944 :   } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
    3082         226 :     Out << " from ";
    3083         226 :     writeOperand(CRI->getOperand(0), /*PrintType=*/false);
    3084             : 
    3085         226 :     Out << " unwind ";
    3086         226 :     if (CRI->hasUnwindDest())
    3087          87 :       writeOperand(CRI->getOperand(1), /*PrintType=*/true);
    3088             :     else
    3089         139 :       Out << "to caller";
    3090     1253718 :   } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
    3091             :     // Print the calling convention being used.
    3092      115937 :     if (CI->getCallingConv() != CallingConv::C) {
    3093        4858 :       Out << " ";
    3094        9716 :       PrintCallingConv(CI->getCallingConv(), Out);
    3095             :     }
    3096             : 
    3097      115937 :     Operand = CI->getCalledValue();
    3098      115937 :     FunctionType *FTy = CI->getFunctionType();
    3099      115937 :     Type *RetTy = FTy->getReturnType();
    3100      115937 :     const AttributeList &PAL = CI->getAttributes();
    3101             : 
    3102      115937 :     if (PAL.hasAttributes(AttributeList::ReturnIndex))
    3103        5888 :       Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
    3104             : 
    3105             :     // If possible, print out the short form of the call instruction.  We can
    3106             :     // only do this if the first argument is a pointer to a nonvararg function,
    3107             :     // and if the return type is not a pointer to a function.
    3108             :     //
    3109      231874 :     Out << ' ';
    3110      231874 :     TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
    3111      231874 :     Out << ' ';
    3112      115937 :     writeOperand(Operand, false);
    3113      231874 :     Out << '(';
    3114      469887 :     for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
    3115      238013 :       if (op > 0)
    3116      139471 :         Out << ", ";
    3117      476026 :       writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
    3118             :     }
    3119             : 
    3120             :     // Emit an ellipsis if this is a musttail call in a vararg function.  This
    3121             :     // is only to aid readability, musttail calls forward varargs by default.
    3122      116137 :     if (CI->isMustTailCall() && CI->getParent() &&
    3123      116137 :         CI->getParent()->getParent() &&
    3124         200 :         CI->getParent()->getParent()->isVarArg())
    3125          51 :       Out << ", ...";
    3126             : 
    3127      231874 :     Out << ')';
    3128      115937 :     if (PAL.hasAttributes(AttributeList::FunctionIndex))
    3129       38351 :       Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
    3130             : 
    3131      115937 :     writeOperandBundles(CI);
    3132     1137781 :   } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
    3133        2357 :     Operand = II->getCalledValue();
    3134        2357 :     FunctionType *FTy = II->getFunctionType();
    3135        2357 :     Type *RetTy = FTy->getReturnType();
    3136        2357 :     const AttributeList &PAL = II->getAttributes();
    3137             : 
    3138             :     // Print the calling convention being used.
    3139        2357 :     if (II->getCallingConv() != CallingConv::C) {
    3140          42 :       Out << " ";
    3141          84 :       PrintCallingConv(II->getCallingConv(), Out);
    3142             :     }
    3143             : 
    3144        2357 :     if (PAL.hasAttributes(AttributeList::ReturnIndex))
    3145         580 :       Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
    3146             : 
    3147             :     // If possible, print out the short form of the invoke instruction. We can
    3148             :     // only do this if the first argument is a pointer to a nonvararg function,
    3149             :     // and if the return type is not a pointer to a function.
    3150             :     //
    3151        4714 :     Out << ' ';
    3152        4714 :     TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
    3153        4714 :     Out << ' ';
    3154        2357 :     writeOperand(Operand, false);
    3155        4714 :     Out << '(';
    3156        6956 :     for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
    3157        2242 :       if (op)
    3158         861 :         Out << ", ";
    3159        4484 :       writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
    3160             :     }
    3161             : 
    3162        4714 :     Out << ')';
    3163        2357 :     if (PAL.hasAttributes(AttributeList::FunctionIndex))
    3164         177 :       Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
    3165             : 
    3166        2357 :     writeOperandBundles(II);
    3167             : 
    3168        2357 :     Out << "\n          to ";
    3169        2357 :     writeOperand(II->getNormalDest(), true);
    3170        2357 :     Out << " unwind ";
    3171        2357 :     writeOperand(II->getUnwindDest(), true);
    3172     1135424 :   } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
    3173      361356 :     Out << ' ';
    3174      180678 :     if (AI->isUsedWithInAlloca())
    3175         112 :       Out << "inalloca ";
    3176      180678 :     if (AI->isSwiftError())
    3177          23 :       Out << "swifterror ";
    3178      180678 :     TypePrinter.print(AI->getAllocatedType(), Out);
    3179             : 
    3180             :     // Explicitly write the array size if the code is broken, if it's an array
    3181             :     // allocation, or if the type is not canonical for scalar allocations.  The
    3182             :     // latter case prevents the type from mutating when round-tripping through
    3183             :     // assembly.
    3184      360835 :     if (!AI->getArraySize() || AI->isArrayAllocation() ||
    3185      180157 :         !AI->getArraySize()->getType()->isIntegerTy(32)) {
    3186         529 :       Out << ", ";
    3187         529 :       writeOperand(AI->getArraySize(), true);
    3188             :     }
    3189      180678 :     if (AI->getAlignment()) {
    3190      356218 :       Out << ", align " << AI->getAlignment();
    3191             :     }
    3192             : 
    3193      361356 :     unsigned AddrSpace = AI->getType()->getAddressSpace();
    3194      180678 :     if (AddrSpace != 0) {
    3195         390 :       Out << ", addrspace(" << AddrSpace << ')';
    3196             :     }
    3197      954746 :   } else if (isa<CastInst>(I)) {
    3198      143309 :     if (Operand) {
    3199      286618 :       Out << ' ';
    3200      143309 :       writeOperand(Operand, true);   // Work with broken code
    3201             :     }
    3202      143309 :     Out << " to ";
    3203      143309 :     TypePrinter.print(I.getType(), Out);
    3204      811437 :   } else if (isa<VAArgInst>(I)) {
    3205          36 :     if (Operand) {
    3206          72 :       Out << ' ';
    3207          36 :       writeOperand(Operand, true);   // Work with broken code
    3208             :     }
    3209          36 :     Out << ", ";
    3210          36 :     TypePrinter.print(I.getType(), Out);
    3211      811401 :   } else if (Operand) {   // Print the normal way.
    3212      808020 :     if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
    3213      168724 :       Out << ' ';
    3214       84362 :       TypePrinter.print(GEP->getSourceElementType(), Out);
    3215       84362 :       Out << ',';
    3216      246061 :     } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
    3217      492122 :       Out << ' ';
    3218      246061 :       TypePrinter.print(LI->getType(), Out);
    3219      246061 :       Out << ',';
    3220             :     }
    3221             : 
    3222             :     // PrintAllTypes - Instructions who have operands of all the same type
    3223             :     // omit the type from all but the first operand.  If the instruction has
    3224             :     // different type operands (for example br), then they are all printed.
    3225      808020 :     bool PrintAllTypes = false;
    3226      808020 :     Type *TheType = Operand->getType();
    3227             : 
    3228             :     // Select, Store and ShuffleVector always print all types.
    3229     2181772 :     if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
    3230     1369902 :         || isa<ReturnInst>(I)) {
    3231             :       PrintAllTypes = true;
    3232             :     } else {
    3233     1133195 :       for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
    3234      438916 :         Operand = I.getOperand(i);
    3235             :         // note that Operand shouldn't be null, but the test helps make dump()
    3236             :         // more tolerant of malformed IR
    3237      219458 :         if (Operand && Operand->getType() != TheType) {
    3238             :           PrintAllTypes = true;    // We have differing types!  Print them all!
    3239             :           break;
    3240             :         }
    3241             :       }
    3242             :     }
    3243             : 
    3244      508209 :     if (!PrintAllTypes) {
    3245      811056 :       Out << ' ';
    3246      405528 :       TypePrinter.print(TheType, Out);
    3247             :     }
    3248             : 
    3249     1616040 :     Out << ' ';
    3250     2971044 :     for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
    3251     1355004 :       if (i) Out << ", ";
    3252     2710008 :       writeOperand(I.getOperand(i), PrintAllTypes);
    3253             :     }
    3254             :   }
    3255             : 
    3256             :   // Print atomic ordering/alignment for memory operations
    3257     1359465 :   if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
    3258      246061 :     if (LI->isAtomic())
    3259        2136 :       writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
    3260      246061 :     if (LI->getAlignment())
    3261      479266 :       Out << ", align " << LI->getAlignment();
    3262     1113404 :   } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
    3263      231034 :     if (SI->isAtomic())
    3264        1050 :       writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
    3265      231034 :     if (SI->getAlignment())
    3266      444250 :       Out << ", align " << SI->getAlignment();
    3267      882370 :   } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
    3268        1956 :     writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
    3269             :                        CXI->getFailureOrdering(), CXI->getSyncScopeID());
    3270      881718 :   } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
    3271        1406 :     writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
    3272             :                 RMWI->getSyncScopeID());
    3273         221 :   } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
    3274         442 :     writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
    3275             :   }
    3276             : 
    3277             :   // Print Metadata info.
    3278     2718930 :   SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
    3279     1359465 :   I.getAllMetadata(InstMD);
    3280     1359465 :   printMetadataAttachments(InstMD, ", ");
    3281             : 
    3282             :   // Print a nice comment.
    3283     1359465 :   printInfoComment(I);
    3284     1359465 : }
    3285             : 
    3286     1558790 : void AssemblyWriter::printMetadataAttachments(
    3287             :     const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
    3288             :     StringRef Separator) {
    3289     1558790 :   if (MDs.empty())
    3290             :     return;
    3291             : 
    3292       70278 :   if (MDNames.empty())
    3293       13179 :     MDs[0].second->getContext().getMDKindNames(MDNames);
    3294             : 
    3295      287618 :   for (const auto &I : MDs) {
    3296       76784 :     unsigned Kind = I.first;
    3297       76784 :     Out << Separator;
    3298      153568 :     if (Kind < MDNames.size()) {
    3299       76784 :       Out << "!";
    3300      153568 :       printMetadataIdentifier(MDNames[Kind], Out);
    3301             :     } else
    3302           0 :       Out << "!<unknown kind #" << Kind << ">";
    3303      153568 :     Out << ' ';
    3304       76784 :     WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
    3305             :   }
    3306             : }
    3307             : 
    3308       65083 : void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
    3309      195249 :   Out << '!' << Slot << " = ";
    3310       65083 :   printMDNodeBody(Node);
    3311       65083 :   Out << "\n";
    3312       65083 : }
    3313             : 
    3314        6918 : void AssemblyWriter::writeAllMDNodes() {
    3315       13836 :   SmallVector<const MDNode *, 16> Nodes;
    3316       13836 :   Nodes.resize(Machine.mdn_size());
    3317       20754 :   for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
    3318       72001 :        I != E; ++I)
    3319      195249 :     Nodes[I->second] = cast<MDNode>(I->first);
    3320             : 
    3321       78919 :   for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
    3322      130166 :     writeMDNode(i, Nodes[i]);
    3323             :   }
    3324        6918 : }
    3325             : 
    3326             : void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
    3327       65083 :   WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
    3328             : }
    3329             : 
    3330        8178 : void AssemblyWriter::writeAllAttributeGroups() {
    3331       16356 :   std::vector<std::pair<AttributeSet, unsigned>> asVec;
    3332       16356 :   asVec.resize(Machine.as_size());
    3333             : 
    3334       24534 :   for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
    3335       27839 :        I != E; ++I)
    3336       58983 :     asVec[I->second] = *I;
    3337             : 
    3338       52373 :   for (const auto &I : asVec)
    3339       39322 :     Out << "attributes #" << I.second << " = { "
    3340       58983 :         << I.first.getAsString(true) << " }\n";
    3341        8178 : }
    3342             : 
    3343         826 : void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
    3344         826 :   bool IsInFunction = Machine.getFunction();
    3345         826 :   if (IsInFunction)
    3346         719 :     Out << "  ";
    3347             : 
    3348         826 :   Out << "uselistorder";
    3349             :   if (const BasicBlock *BB =
    3350         826 :           IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
    3351           0 :     Out << "_bb ";
    3352           0 :     writeOperand(BB->getParent(), false);
    3353           0 :     Out << ", ";
    3354           0 :     writeOperand(BB, false);
    3355             :   } else {
    3356         826 :     Out << " ";
    3357         826 :     writeOperand(Order.V, true);
    3358             :   }
    3359         826 :   Out << ", { ";
    3360             : 
    3361             :   assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
    3362        1652 :   Out << Order.Shuffle[0];
    3363        3944 :   for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
    3364        6876 :     Out << ", " << Order.Shuffle[I];
    3365         826 :   Out << " }\n";
    3366         826 : }
    3367             : 
    3368      106441 : void AssemblyWriter::printUseLists(const Function *F) {
    3369             :   auto hasMore =
    3370      217213 :       [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
    3371         380 :   if (!hasMore())
    3372             :     // Nothing to do.
    3373             :     return;
    3374             : 
    3375         380 :   Out << "\n; uselistorder directives\n";
    3376         826 :   while (hasMore()) {
    3377        1652 :     printUseListOrder(UseListOrders.back());
    3378         826 :     UseListOrders.pop_back();
    3379             :   }
    3380             : }
    3381             : 
    3382             : //===----------------------------------------------------------------------===//
    3383             : //                       External Interface declarations
    3384             : //===----------------------------------------------------------------------===//
    3385             : 
    3386         124 : void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
    3387             :                      bool ShouldPreserveUseListOrder,
    3388             :                      bool IsForDebug) const {
    3389         248 :   SlotTracker SlotTable(this->getParent());
    3390         248 :   formatted_raw_ostream OS(ROS);
    3391             :   AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
    3392             :                    IsForDebug,
    3393         248 :                    ShouldPreserveUseListOrder);
    3394         124 :   W.printFunction(this);
    3395         124 : }
    3396             : 
    3397       12402 : void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
    3398             :                    bool ShouldPreserveUseListOrder, bool IsForDebug) const {
    3399       24804 :   SlotTracker SlotTable(this);
    3400       24804 :   formatted_raw_ostream OS(ROS);
    3401             :   AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
    3402       24804 :                    ShouldPreserveUseListOrder);
    3403       12402 :   W.printModule(this);
    3404       12402 : }
    3405             : 
    3406           1 : void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
    3407           2 :   SlotTracker SlotTable(getParent());
    3408           2 :   formatted_raw_ostream OS(ROS);
    3409           2 :   AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
    3410           1 :   W.printNamedMDNode(this);
    3411           1 : }
    3412             : 
    3413          10 : void NamedMDNode::print(raw_ostream &ROS, ModuleSlotTracker &MST,
    3414             :                         bool IsForDebug) const {
    3415          20 :   Optional<SlotTracker> LocalST;
    3416             :   SlotTracker *SlotTable;
    3417          10 :   if (auto *ST = MST.getMachine())
    3418             :     SlotTable = ST;
    3419             :   else {
    3420           0 :     LocalST.emplace(getParent());
    3421           0 :     SlotTable = &*LocalST;
    3422             :   }
    3423             : 
    3424          20 :   formatted_raw_ostream OS(ROS);
    3425          20 :   AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
    3426          10 :   W.printNamedMDNode(this);
    3427          10 : }
    3428             : 
    3429       13526 : void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
    3430       13526 :   PrintLLVMName(ROS, getName(), ComdatPrefix);
    3431       13526 :   ROS << " = comdat ";
    3432             : 
    3433       13526 :   switch (getSelectionKind()) {
    3434       13333 :   case Comdat::Any:
    3435       13333 :     ROS << "any";
    3436       13333 :     break;
    3437           9 :   case Comdat::ExactMatch:
    3438           9 :     ROS << "exactmatch";
    3439           9 :     break;
    3440         164 :   case Comdat::Largest:
    3441         164 :     ROS << "largest";
    3442         164 :     break;
    3443          13 :   case Comdat::NoDuplicates:
    3444          13 :     ROS << "noduplicates";
    3445          13 :     break;
    3446           7 :   case Comdat::SameSize:
    3447           7 :     ROS << "samesize";
    3448           7 :     break;
    3449             :   }
    3450             : 
    3451       13526 :   ROS << '\n';
    3452       13526 : }
    3453             : 
    3454       22801 : void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
    3455       45602 :   TypePrinting TP;
    3456       22801 :   TP.print(const_cast<Type*>(this), OS);
    3457             : 
    3458       22801 :   if (NoDetails)
    3459           0 :     return;
    3460             : 
    3461             :   // If the type is a named struct type, print the body as well.
    3462          79 :   if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
    3463          79 :     if (!STy->isLiteral()) {
    3464          77 :       OS << " = type ";
    3465          77 :       TP.printStructBody(STy, OS);
    3466             :     }
    3467             : }
    3468             : 
    3469       24206 : static bool isReferencingMDNode(const Instruction &I) {
    3470        2743 :   if (const auto *CI = dyn_cast<CallInst>(&I))
    3471        2735 :     if (Function *F = CI->getCalledFunction())
    3472        2735 :       if (F->isIntrinsic())
    3473        7286 :         for (auto &Op : I.operands())
    3474           3 :           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
    3475           3 :             if (isa<MDNode>(V->getMetadata()))
    3476             :               return true;
    3477             :   return false;
    3478             : }
    3479             : 
    3480       24634 : void Value::print(raw_ostream &ROS, bool IsForDebug) const {
    3481       24634 :   bool ShouldInitializeAllMetadata = false;
    3482       24634 :   if (auto *I = dyn_cast<Instruction>(this))
    3483       24206 :     ShouldInitializeAllMetadata = isReferencingMDNode(*I);
    3484        1081 :   else if (isa<Function>(this) || isa<MetadataAsValue>(this))
    3485             :     ShouldInitializeAllMetadata = true;
    3486             : 
    3487       49268 :   ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
    3488       24634 :   print(ROS, MST, IsForDebug);
    3489       24634 : }
    3490             : 
    3491       24885 : void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST,
    3492             :                   bool IsForDebug) const {
    3493       49770 :   formatted_raw_ostream OS(ROS);
    3494       49770 :   SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
    3495             :   SlotTracker &SlotTable =
    3496       24885 :       MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
    3497             :   auto incorporateFunction = [&](const Function *F) {
    3498       24439 :     if (F)
    3499       24439 :       MST.incorporateFunction(*F);
    3500       24885 :   };
    3501             : 
    3502       24885 :   if (const Instruction *I = dyn_cast<Instruction>(this)) {
    3503       48910 :     incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
    3504       48910 :     AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
    3505       24455 :     W.printInstruction(*I);
    3506         430 :   } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
    3507          44 :     incorporateFunction(BB->getParent());
    3508          44 :     AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
    3509          22 :     W.printBasicBlock(BB);
    3510         408 :   } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
    3511         424 :     AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
    3512         212 :     if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
    3513           9 :       W.printGlobal(V);
    3514         203 :     else if (const Function *F = dyn_cast<Function>(GV))
    3515         203 :       W.printFunction(F);
    3516             :     else
    3517           0 :       W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
    3518         196 :   } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
    3519           4 :     V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
    3520          55 :   } else if (const Constant *C = dyn_cast<Constant>(this)) {
    3521         110 :     TypePrinting TypePrinter;
    3522          55 :     TypePrinter.print(C->getType(), OS);
    3523          55 :     OS << ' ';
    3524          55 :     WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
    3525         411 :   } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
    3526         137 :     this->printAsOperand(OS, /* PrintType */ true, MST);
    3527             :   } else {
    3528           0 :     llvm_unreachable("Unknown value to print out!");
    3529             :   }
    3530       24885 : }
    3531             : 
    3532             : /// Print without a type, skipping the TypePrinting object.
    3533             : ///
    3534             : /// \return \c true iff printing was successful.
    3535      249517 : static bool printWithoutType(const Value &V, raw_ostream &O,
    3536             :                              SlotTracker *Machine, const Module *M) {
    3537      259034 :   if (V.hasName() || isa<GlobalValue>(V) ||
    3538         825 :       (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
    3539      240821 :     WriteAsOperandInternal(O, &V, nullptr, Machine, M);
    3540      240821 :     return true;
    3541             :   }
    3542             :   return false;
    3543             : }
    3544             : 
    3545       20191 : static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
    3546             :                                ModuleSlotTracker &MST) {
    3547       40382 :   TypePrinting TypePrinter;
    3548       20191 :   if (const Module *M = MST.getModule())
    3549       11483 :     TypePrinter.incorporateTypes(*M);
    3550       20191 :   if (PrintType) {
    3551       11495 :     TypePrinter.print(V.getType(), O);
    3552             :     O << ' ';
    3553             :   }
    3554             : 
    3555       20191 :   WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
    3556             :                          MST.getModule());
    3557       20191 : }
    3558             : 
    3559      241616 : void Value::printAsOperand(raw_ostream &O, bool PrintType,
    3560             :                            const Module *M) const {
    3561      241616 :   if (!M)
    3562       25324 :     M = getModuleFromVal(this);
    3563             : 
    3564      241616 :   if (!PrintType)
    3565      231074 :     if (printWithoutType(*this, O, nullptr, M))
    3566      222386 :       return;
    3567             : 
    3568             :   SlotTracker Machine(
    3569       57690 :       M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
    3570       38460 :   ModuleSlotTracker MST(Machine, M);
    3571       19230 :   printAsOperandImpl(*this, O, PrintType, MST);
    3572             : }
    3573             : 
    3574       19396 : void Value::printAsOperand(raw_ostream &O, bool PrintType,
    3575             :                            ModuleSlotTracker &MST) const {
    3576       19396 :   if (!PrintType)
    3577       18443 :     if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
    3578             :       return;
    3579             : 
    3580         961 :   printAsOperandImpl(*this, O, PrintType, MST);
    3581             : }
    3582             : 
    3583        1559 : static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
    3584             :                               ModuleSlotTracker &MST, const Module *M,
    3585             :                               bool OnlyAsOperand) {
    3586        1714 :   formatted_raw_ostream OS(ROS);
    3587             : 
    3588        1714 :   TypePrinting TypePrinter;
    3589        1559 :   if (M)
    3590         175 :     TypePrinter.incorporateTypes(*M);
    3591             : 
    3592        1559 :   WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
    3593             :                          /* FromValue */ true);
    3594             : 
    3595        1559 :   auto *N = dyn_cast<MDNode>(&MD);
    3596        1718 :   if (OnlyAsOperand || !N || isa<DIExpression>(MD))
    3597        1404 :     return;
    3598             : 
    3599         155 :   OS << " = ";
    3600         155 :   WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
    3601             : }
    3602             : 
    3603           2 : void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
    3604           6 :   ModuleSlotTracker MST(M, isa<MDNode>(this));
    3605           2 :   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
    3606           2 : }
    3607             : 
    3608        1376 : void Metadata::printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
    3609             :                               const Module *M) const {
    3610        1376 :   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
    3611        1376 : }
    3612             : 
    3613          10 : void Metadata::print(raw_ostream &OS, const Module *M,
    3614             :                      bool /*IsForDebug*/) const {
    3615          30 :   ModuleSlotTracker MST(M, isa<MDNode>(this));
    3616          10 :   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
    3617          10 : }
    3618             : 
    3619         171 : void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
    3620             :                      const Module *M, bool /*IsForDebug*/) const {
    3621         171 :   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
    3622         171 : }
    3623             : 
    3624             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    3625             : // Value::dump - allow easy printing of Values from the debugger.
    3626             : LLVM_DUMP_METHOD
    3627             : void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
    3628             : 
    3629             : // Type::dump - allow easy printing of Types from the debugger.
    3630             : LLVM_DUMP_METHOD
    3631             : void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
    3632             : 
    3633             : // Module::dump() - Allow printing of Modules from the debugger.
    3634             : LLVM_DUMP_METHOD
    3635             : void Module::dump() const {
    3636             :   print(dbgs(), nullptr,
    3637             :         /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
    3638             : }
    3639             : 
    3640             : // \brief Allow printing of Comdats from the debugger.
    3641             : LLVM_DUMP_METHOD
    3642             : void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
    3643             : 
    3644             : // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
    3645             : LLVM_DUMP_METHOD
    3646             : void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
    3647             : 
    3648             : LLVM_DUMP_METHOD
    3649             : void Metadata::dump() const { dump(nullptr); }
    3650             : 
    3651             : LLVM_DUMP_METHOD
    3652             : void Metadata::dump(const Module *M) const {
    3653             :   print(dbgs(), M, /*IsForDebug=*/true);
    3654             :   dbgs() << '\n';
    3655             : }
    3656             : #endif

Generated by: LCOV version 1.13