lib/IR/AsmWriter.cpp

   1 //===- AsmWriter.cpp - Printing LLVM as an assembly file ------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This library implements `print` family of functions in classes like
  10 // Module, Function, Value, etc. In-memory representation of those classes is
  11 // converted to IR strings.
  12 //
  13 // Note that these routines must be extremely tolerant of various errors in the
  14 // LLVM code, because it can be used for debugging transformations.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "llvm/ADT/APFloat.h"
  19 #include "llvm/ADT/APInt.h"
  20 #include "llvm/ADT/ArrayRef.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/None.h"
  23 #include "llvm/ADT/Optional.h"
  24 #include "llvm/ADT/STLExtras.h"
  25 #include "llvm/ADT/SetVector.h"
  26 #include "llvm/ADT/SmallString.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/ADT/StringExtras.h"
  29 #include "llvm/ADT/StringRef.h"
  30 #include "llvm/ADT/iterator_range.h"
  31 #include "llvm/BinaryFormat/Dwarf.h"
  32 #include "llvm/Config/llvm-config.h"
  33 #include "llvm/IR/Argument.h"
  34 #include "llvm/IR/AssemblyAnnotationWriter.h"
  35 #include "llvm/IR/Attributes.h"
  36 #include "llvm/IR/BasicBlock.h"
  37 #include "llvm/IR/CFG.h"
  38 #include "llvm/IR/CallingConv.h"
  39 #include "llvm/IR/Comdat.h"
  40 #include "llvm/IR/Constant.h"
  41 #include "llvm/IR/Constants.h"
  42 #include "llvm/IR/DebugInfoMetadata.h"
  43 #include "llvm/IR/DerivedTypes.h"
  44 #include "llvm/IR/Function.h"
  45 #include "llvm/IR/GlobalAlias.h"
  46 #include "llvm/IR/GlobalIFunc.h"
  47 #include "llvm/IR/GlobalIndirectSymbol.h"
  48 #include "llvm/IR/GlobalObject.h"
  49 #include "llvm/IR/GlobalValue.h"
  50 #include "llvm/IR/GlobalVariable.h"
  51 #include "llvm/IR/IRPrintingPasses.h"
  52 #include "llvm/IR/InlineAsm.h"
  53 #include "llvm/IR/InstrTypes.h"
  54 #include "llvm/IR/Instruction.h"
  55 #include "llvm/IR/Instructions.h"
  56 #include "llvm/IR/LLVMContext.h"
  57 #include "llvm/IR/Metadata.h"
  58 #include "llvm/IR/Module.h"
  59 #include "llvm/IR/ModuleSlotTracker.h"
  60 #include "llvm/IR/ModuleSummaryIndex.h"
  61 #include "llvm/IR/Operator.h"
  62 #include "llvm/IR/Statepoint.h"
  63 #include "llvm/IR/Type.h"
  64 #include "llvm/IR/TypeFinder.h"
  65 #include "llvm/IR/Use.h"
  66 #include "llvm/IR/UseListOrder.h"
  67 #include "llvm/IR/User.h"
  68 #include "llvm/IR/Value.h"
  69 #include "llvm/Support/AtomicOrdering.h"
  70 #include "llvm/Support/Casting.h"
  71 #include "llvm/Support/Compiler.h"
  72 #include "llvm/Support/Debug.h"
  73 #include "llvm/Support/ErrorHandling.h"
  74 #include "llvm/Support/Format.h"
  75 #include "llvm/Support/FormattedStream.h"
  76 #include "llvm/Support/raw_ostream.h"
  77 #include <algorithm>
  78 #include <cassert>
  79 #include <cctype>
  80 #include <cstddef>
  81 #include <cstdint>
  82 #include <iterator>
  83 #include <memory>
  84 #include <string>
  85 #include <tuple>
  86 #include <utility>
  87 #include <vector>
  88
  89 using namespace llvm;
  90
  91 // Make virtual table appear in this compilation unit.
  92 AssemblyAnnotationWriter::~AssemblyAnnotationWriter() = default;
  93
  94 //===----------------------------------------------------------------------===//
  95 // Helper Functions
  96 //===----------------------------------------------------------------------===//
  97
  98 namespace {
  99
 100 struct OrderMap {
 101   DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
 102
 103   unsigned size() const { return IDs.size(); }
 104   std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
 105
 106   std::pair<unsigned, bool> lookup(const Value *V) const {
 107     return IDs.lookup(V);
 108   }
 109
 110   void index(const Value *V) {
 111     // Explicitly sequence get-size and insert-value operations to avoid UB.
 112     unsigned ID = IDs.size() + 1;
 113     IDs[V].first = ID;
 114   }
 115 };
 116
 117 } // end anonymous namespace
 118
 119 static void orderValue(const Value *V, OrderMap &OM) {
 120   if (OM.lookup(V).first)
 121     return;
 122
 123   if (const Constant *C = dyn_cast<Constant>(V))
 124     if (C->getNumOperands() && !isa<GlobalValue>(C))
 125       for (const Value *Op : C->operands())
 126         if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
 127           orderValue(Op, OM);
 128
 129   // Note: we cannot cache this lookup above, since inserting into the map
 130   // changes the map's size, and thus affects the other IDs.
 131   OM.index(V);
 132 }
 133
 134 static OrderMap orderModule(const Module *M) {
 135   // This needs to match the order used by ValueEnumerator::ValueEnumerator()
 136   // and ValueEnumerator::incorporateFunction().
 137   OrderMap OM;
 138
 139   for (const GlobalVariable &G : M->globals()) {
 140     if (G.hasInitializer())
 141       if (!isa<GlobalValue>(G.getInitializer()))
 142         orderValue(G.getInitializer(), OM);
 143     orderValue(&G, OM);
 144   }
 145   for (const GlobalAlias &A : M->aliases()) {
 146     if (!isa<GlobalValue>(A.getAliasee()))
 147       orderValue(A.getAliasee(), OM);
 148     orderValue(&A, OM);
 149   }
 150   for (const GlobalIFunc &I : M->ifuncs()) {
 151     if (!isa<GlobalValue>(I.getResolver()))
 152       orderValue(I.getResolver(), OM);
 153     orderValue(&I, OM);
 154   }
 155   for (const Function &F : *M) {
 156     for (const Use &U : F.operands())
 157       if (!isa<GlobalValue>(U.get()))
 158         orderValue(U.get(), OM);
 159
 160     orderValue(&F, OM);
 161
 162     if (F.isDeclaration())
 163       continue;
 164
 165     for (const Argument &A : F.args())
 166       orderValue(&A, OM);
 167     for (const BasicBlock &BB : F) {
 168       orderValue(&BB, OM);
 169       for (const Instruction &I : BB) {
 170         for (const Value *Op : I.operands())
 171           if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
 172               isa<InlineAsm>(*Op))
 173             orderValue(Op, OM);
 174         orderValue(&I, OM);
 175       }
 176     }
 177   }
 178   return OM;
 179 }
 180
 181 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
 182                                          unsigned ID, const OrderMap &OM,
 183                                          UseListOrderStack &Stack) {
 184   // Predict use-list order for this one.
 185   using Entry = std::pair<const Use *, unsigned>;
 186   SmallVector<Entry, 64> List;
 187   for (const Use &U : V->uses())
 188     // Check if this user will be serialized.
 189     if (OM.lookup(U.getUser()).first)
 190       List.push_back(std::make_pair(&U, List.size()));
 191
 192   if (List.size() < 2)
 193     // We may have lost some users.
 194     return;
 195
 196   bool GetsReversed =
 197       !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
 198   if (auto *BA = dyn_cast<BlockAddress>(V))
 199     ID = OM.lookup(BA->getBasicBlock()).first;
 200   llvm::sort(List, [&](const Entry &L, const Entry &R) {
 201     const Use *LU = L.first;
 202     const Use *RU = R.first;
 203     if (LU == RU)
 204       return false;
 205
 206     auto LID = OM.lookup(LU->getUser()).first;
 207     auto RID = OM.lookup(RU->getUser()).first;
 208
 209     // If ID is 4, then expect: 7 6 5 1 2 3.
 210     if (LID < RID) {
 211       if (GetsReversed)
 212         if (RID <= ID)
 213           return true;
 214       return false;
 215     }
 216     if (RID < LID) {
 217       if (GetsReversed)
 218         if (LID <= ID)
 219           return false;
 220       return true;
 221     }
 222
 223     // LID and RID are equal, so we have different operands of the same user.
 224     // Assume operands are added in order for all instructions.
 225     if (GetsReversed)
 226       if (LID <= ID)
 227         return LU->getOperandNo() < RU->getOperandNo();
 228     return LU->getOperandNo() > RU->getOperandNo();
 229   });
 230
 231   if (std::is_sorted(
 232           List.begin(), List.end(),
 233           [](const Entry &L, const Entry &R) { return L.second < R.second; }))
 234     // Order is already correct.
 235     return;
 236
 237   // Store the shuffle.
 238   Stack.emplace_back(V, F, List.size());
 239   assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
 240   for (size_t I = 0, E = List.size(); I != E; ++I)
 241     Stack.back().Shuffle[I] = List[I].second;
 242 }
 243
 244 static void predictValueUseListOrder(const Value *V, const Function *F,
 245                                      OrderMap &OM, UseListOrderStack &Stack) {
 246   auto &IDPair = OM[V];
 247   assert(IDPair.first && "Unmapped value");
 248   if (IDPair.second)
 249     // Already predicted.
 250     return;
 251
 252   // Do the actual prediction.
 253   IDPair.second = true;
 254   if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())
 255     predictValueUseListOrderImpl(V, F, IDPair.first, OM, Stack);
 256
 257   // Recursive descent into constants.
 258   if (const Constant *C = dyn_cast<Constant>(V))
 259     if (C->getNumOperands()) // Visit GlobalValues.
 260       for (const Value *Op : C->operands())
 261         if (isa<Constant>(Op)) // Visit GlobalValues.
 262           predictValueUseListOrder(Op, F, OM, Stack);
 263 }
 264
 265 static UseListOrderStack predictUseListOrder(const Module *M) {
 266   OrderMap OM = orderModule(M);
 267
 268   // Use-list orders need to be serialized after all the users have been added
 269   // to a value, or else the shuffles will be incomplete.  Store them per
 270   // function in a stack.
 271   //
 272   // Aside from function order, the order of values doesn't matter much here.
 273   UseListOrderStack Stack;
 274
 275   // We want to visit the functions backward now so we can list function-local
 276   // constants in the last Function they're used in.  Module-level constants
 277   // have already been visited above.
 278   for (const Function &F : make_range(M->rbegin(), M->rend())) {
 279     if (F.isDeclaration())
 280       continue;
 281     for (const BasicBlock &BB : F)
 282       predictValueUseListOrder(&BB, &F, OM, Stack);
 283     for (const Argument &A : F.args())
 284       predictValueUseListOrder(&A, &F, OM, Stack);
 285     for (const BasicBlock &BB : F)
 286       for (const Instruction &I : BB)
 287         for (const Value *Op : I.operands())
 288           if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
 289             predictValueUseListOrder(Op, &F, OM, Stack);
 290     for (const BasicBlock &BB : F)
 291       for (const Instruction &I : BB)
 292         predictValueUseListOrder(&I, &F, OM, Stack);
 293   }
 294
 295   // Visit globals last.
 296   for (const GlobalVariable &G : M->globals())
 297     predictValueUseListOrder(&G, nullptr, OM, Stack);
 298   for (const Function &F : *M)
 299     predictValueUseListOrder(&F, nullptr, OM, Stack);
 300   for (const GlobalAlias &A : M->aliases())
 301     predictValueUseListOrder(&A, nullptr, OM, Stack);
 302   for (const GlobalIFunc &I : M->ifuncs())
 303     predictValueUseListOrder(&I, nullptr, OM, Stack);
 304   for (const GlobalVariable &G : M->globals())
 305     if (G.hasInitializer())
 306       predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
 307   for (const GlobalAlias &A : M->aliases())
 308     predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
 309   for (const GlobalIFunc &I : M->ifuncs())
 310     predictValueUseListOrder(I.getResolver(), nullptr, OM, Stack);
 311   for (const Function &F : *M)
 312     for (const Use &U : F.operands())
 313       predictValueUseListOrder(U.get(), nullptr, OM, Stack);
 314
 315   return Stack;
 316 }
 317
 318 static const Module *getModuleFromVal(const Value *V) {
 319   if (const Argument *MA = dyn_cast<Argument>(V))
 320     return MA->getParent() ? MA->getParent()->getParent() : nullptr;
 321
 322   if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
 323     return BB->getParent() ? BB->getParent()->getParent() : nullptr;
 324
 325   if (const Instruction *I = dyn_cast<Instruction>(V)) {
 326     const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
 327     return M ? M->getParent() : nullptr;
 328   }
 329
 330   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
 331     return GV->getParent();
 332
 333   if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
 334     for (const User *U : MAV->users())
 335       if (isa<Instruction>(U))
 336         if (const Module *M = getModuleFromVal(U))
 337           return M;
 338     return nullptr;
 339   }
 340
 341   return nullptr;
 342 }
 343
 344 static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
 345   switch (cc) {
 346   default:                         Out << "cc" << cc; break;
 347   case CallingConv::Fast:          Out << "fastcc"; break;
 348   case CallingConv::Cold:          Out << "coldcc"; break;
 349   case CallingConv::WebKit_JS:     Out << "webkit_jscc"; break;
 350   case CallingConv::AnyReg:        Out << "anyregcc"; break;
 351   case CallingConv::PreserveMost:  Out << "preserve_mostcc"; break;
 352   case CallingConv::PreserveAll:   Out << "preserve_allcc"; break;
 353   case CallingConv::CXX_FAST_TLS:  Out << "cxx_fast_tlscc"; break;
 354   case CallingConv::GHC:           Out << "ghccc"; break;
 355   case CallingConv::X86_StdCall:   Out << "x86_stdcallcc"; break;
 356   case CallingConv::X86_FastCall:  Out << "x86_fastcallcc"; break;
 357   case CallingConv::X86_ThisCall:  Out << "x86_thiscallcc"; break;
 358   case CallingConv::X86_RegCall:   Out << "x86_regcallcc"; break;
 359   case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
 360   case CallingConv::Intel_OCL_BI:  Out << "intel_ocl_bicc"; break;
 361   case CallingConv::ARM_APCS:      Out << "arm_apcscc"; break;
 362   case CallingConv::ARM_AAPCS:     Out << "arm_aapcscc"; break;
 363   case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
 364   case CallingConv::AArch64_VectorCall: Out << "aarch64_vector_pcs"; break;
 365   case CallingConv::MSP430_INTR:   Out << "msp430_intrcc"; break;
 366   case CallingConv::AVR_INTR:      Out << "avr_intrcc "; break;
 367   case CallingConv::AVR_SIGNAL:    Out << "avr_signalcc "; break;
 368   case CallingConv::PTX_Kernel:    Out << "ptx_kernel"; break;
 369   case CallingConv::PTX_Device:    Out << "ptx_device"; break;
 370   case CallingConv::X86_64_SysV:   Out << "x86_64_sysvcc"; break;
 371   case CallingConv::Win64:         Out << "win64cc"; break;
 372   case CallingConv::SPIR_FUNC:     Out << "spir_func"; break;
 373   case CallingConv::SPIR_KERNEL:   Out << "spir_kernel"; break;
 374   case CallingConv::Swift:         Out << "swiftcc"; break;
 375   case CallingConv::X86_INTR:      Out << "x86_intrcc"; break;
 376   case CallingConv::HHVM:          Out << "hhvmcc"; break;
 377   case CallingConv::HHVM_C:        Out << "hhvm_ccc"; break;
 378   case CallingConv::AMDGPU_VS:     Out << "amdgpu_vs"; break;
 379   case CallingConv::AMDGPU_LS:     Out << "amdgpu_ls"; break;
 380   case CallingConv::AMDGPU_HS:     Out << "amdgpu_hs"; break;
 381   case CallingConv::AMDGPU_ES:     Out << "amdgpu_es"; break;
 382   case CallingConv::AMDGPU_GS:     Out << "amdgpu_gs"; break;
 383   case CallingConv::AMDGPU_PS:     Out << "amdgpu_ps"; break;
 384   case CallingConv::AMDGPU_CS:     Out << "amdgpu_cs"; break;
 385   case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
 386   }
 387 }
 388
 389 enum PrefixType {
 390   GlobalPrefix,
 391   ComdatPrefix,
 392   LabelPrefix,
 393   LocalPrefix,
 394   NoPrefix
 395 };
 396
 397 void llvm::printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name) {
 398   assert(!Name.empty() && "Cannot get empty name!");
 399
 400   // Scan the name to see if it needs quotes first.
 401   bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
 402   if (!NeedsQuotes) {
 403     for (unsigned i = 0, e = Name.size(); i != e; ++i) {
 404       // By making this unsigned, the value passed in to isalnum will always be
 405       // in the range 0-255.  This is important when building with MSVC because
 406       // its implementation will assert.  This situation can arise when dealing
 407       // with UTF-8 multibyte characters.
 408       unsigned char C = Name[i];
 409       if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
 410           C != '_') {
 411         NeedsQuotes = true;
 412         break;
 413       }
 414     }
 415   }
 416
 417   // If we didn't need any quotes, just write out the name in one blast.
 418   if (!NeedsQuotes) {
 419     OS << Name;
 420     return;
 421   }
 422
 423   // Okay, we need quotes.  Output the quotes and escape any scary characters as
 424   // needed.
 425   OS << '"';
 426   printEscapedString(Name, OS);
 427   OS << '"';
 428 }
 429
 430 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
 431 /// (if the string only contains simple characters) or is surrounded with ""'s
 432 /// (if it has special chars in it). Print it out.
 433 static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
 434   switch (Prefix) {
 435   case NoPrefix:
 436     break;
 437   case GlobalPrefix:
 438     OS << '@';
 439     break;
 440   case ComdatPrefix:
 441     OS << '$';
 442     break;
 443   case LabelPrefix:
 444     break;
 445   case LocalPrefix:
 446     OS << '%';
 447     break;
 448   }
 449   printLLVMNameWithoutPrefix(OS, Name);
 450 }
 451
 452 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
 453 /// (if the string only contains simple characters) or is surrounded with ""'s
 454 /// (if it has special chars in it). Print it out.
 455 static void PrintLLVMName(raw_ostream &OS, const Value *V) {
 456   PrintLLVMName(OS, V->getName(),
 457                 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
 458 }
 459
 460 namespace {
 461
 462 class TypePrinting {
 463 public:
 464   TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
 465
 466   TypePrinting(const TypePrinting &) = delete;
 467   TypePrinting &operator=(const TypePrinting &) = delete;
 468
 469   /// The named types that are used by the current module.
 470   TypeFinder &getNamedTypes();
 471
 472   /// The numbered types, number to type mapping.
 473   std::vector<StructType *> &getNumberedTypes();
 474
 475   bool empty();
 476
 477   void print(Type *Ty, raw_ostream &OS);
 478
 479   void printStructBody(StructType *Ty, raw_ostream &OS);
 480
 481 private:
 482   void incorporateTypes();
 483
 484   /// A module to process lazily when needed. Set to nullptr as soon as used.
 485   const Module *DeferredM;
 486
 487   TypeFinder NamedTypes;
 488
 489   // The numbered types, along with their value.
 490   DenseMap<StructType *, unsigned> Type2Number;
 491
 492   std::vector<StructType *> NumberedTypes;
 493 };
 494
 495 } // end anonymous namespace
 496
 497 TypeFinder &TypePrinting::getNamedTypes() {
 498   incorporateTypes();
 499   return NamedTypes;
 500 }
 501
 502 std::vector<StructType *> &TypePrinting::getNumberedTypes() {
 503   incorporateTypes();
 504
 505   // We know all the numbers that each type is used and we know that it is a
 506   // dense assignment. Convert the map to an index table, if it's not done
 507   // already (judging from the sizes):
 508   if (NumberedTypes.size() == Type2Number.size())
 509     return NumberedTypes;
 510
 511   NumberedTypes.resize(Type2Number.size());
 512   for (const auto &P : Type2Number) {
 513     assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?");
 514     assert(!NumberedTypes[P.second] && "Didn't get a unique numbering?");
 515     NumberedTypes[P.second] = P.first;
 516   }
 517   return NumberedTypes;
 518 }
 519
 520 bool TypePrinting::empty() {
 521   incorporateTypes();
 522   return NamedTypes.empty() && Type2Number.empty();
 523 }
 524
 525 void TypePrinting::incorporateTypes() {
 526   if (!DeferredM)
 527     return;
 528
 529   NamedTypes.run(*DeferredM, false);
 530   DeferredM = nullptr;
 531
 532   // The list of struct types we got back includes all the struct types, split
 533   // the unnamed ones out to a numbering and remove the anonymous structs.
 534   unsigned NextNumber = 0;
 535
 536   std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
 537   for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
 538     StructType *STy = *I;
 539
 540     // Ignore anonymous types.
 541     if (STy->isLiteral())
 542       continue;
 543
 544     if (STy->getName().empty())
 545       Type2Number[STy] = NextNumber++;
 546     else
 547       *NextToUse++ = STy;
 548   }
 549
 550   NamedTypes.erase(NextToUse, NamedTypes.end());
 551 }
 552
 553 /// Write the specified type to the specified raw_ostream, making use of type
 554 /// names or up references to shorten the type name where possible.
 555 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
 556   switch (Ty->getTypeID()) {
 557   case Type::VoidTyID:      OS << "void"; return;
 558   case Type::HalfTyID:      OS << "half"; return;
 559   case Type::FloatTyID:     OS << "float"; return;
 560   case Type::DoubleTyID:    OS << "double"; return;
 561   case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
 562   case Type::FP128TyID:     OS << "fp128"; return;
 563   case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
 564   case Type::LabelTyID:     OS << "label"; return;
 565   case Type::MetadataTyID:  OS << "metadata"; return;
 566   case Type::X86_MMXTyID:   OS << "x86_mmx"; return;
 567   case Type::TokenTyID:     OS << "token"; return;
 568   case Type::IntegerTyID:
 569     OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
 570     return;
 571
 572   case Type::FunctionTyID: {
 573     FunctionType *FTy = cast<FunctionType>(Ty);
 574     print(FTy->getReturnType(), OS);
 575     OS << " (";
 576     for (FunctionType::param_iterator I = FTy->param_begin(),
 577          E = FTy->param_end(); I != E; ++I) {
 578       if (I != FTy->param_begin())
 579         OS << ", ";
 580       print(*I, OS);
 581     }
 582     if (FTy->isVarArg()) {
 583       if (FTy->getNumParams()) OS << ", ";
 584       OS << "...";
 585     }
 586     OS << ')';
 587     return;
 588   }
 589   case Type::StructTyID: {
 590     StructType *STy = cast<StructType>(Ty);
 591
 592     if (STy->isLiteral())
 593       return printStructBody(STy, OS);
 594
 595     if (!STy->getName().empty())
 596       return PrintLLVMName(OS, STy->getName(), LocalPrefix);
 597
 598     incorporateTypes();
 599     const auto I = Type2Number.find(STy);
 600     if (I != Type2Number.end())
 601       OS << '%' << I->second;
 602     else  // Not enumerated, print the hex address.
 603       OS << "%\"type " << STy << '\"';
 604     return;
 605   }
 606   case Type::PointerTyID: {
 607     PointerType *PTy = cast<PointerType>(Ty);
 608     print(PTy->getElementType(), OS);
 609     if (unsigned AddressSpace = PTy->getAddressSpace())
 610       OS << " addrspace(" << AddressSpace << ')';
 611     OS << '*';
 612     return;
 613   }
 614   case Type::ArrayTyID: {
 615     ArrayType *ATy = cast<ArrayType>(Ty);
 616     OS << '[' << ATy->getNumElements() << " x ";
 617     print(ATy->getElementType(), OS);
 618     OS << ']';
 619     return;
 620   }
 621   case Type::VectorTyID: {
 622     VectorType *PTy = cast<VectorType>(Ty);
 623     OS << "<" << PTy->getNumElements() << " x ";
 624     print(PTy->getElementType(), OS);
 625     OS << '>';
 626     return;
 627   }
 628   }
 629   llvm_unreachable("Invalid TypeID");
 630 }
 631
 632 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
 633   if (STy->isOpaque()) {
 634     OS << "opaque";
 635     return;
 636   }
 637
 638   if (STy->isPacked())
 639     OS << '<';
 640
 641   if (STy->getNumElements() == 0) {
 642     OS << "{}";
 643   } else {
 644     StructType::element_iterator I = STy->element_begin();
 645     OS << "{ ";
 646     print(*I++, OS);
 647     for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
 648       OS << ", ";
 649       print(*I, OS);
 650     }
 651
 652     OS << " }";
 653   }
 654   if (STy->isPacked())
 655     OS << '>';
 656 }
 657
 658 namespace llvm {
 659
 660 //===----------------------------------------------------------------------===//
 661 // SlotTracker Class: Enumerate slot numbers for unnamed values
 662 //===----------------------------------------------------------------------===//
 663 /// This class provides computation of slot numbers for LLVM Assembly writing.
 664 ///
 665 class SlotTracker {
 666 public:
 667   /// ValueMap - A mapping of Values to slot numbers.
 668   using ValueMap = DenseMap<const Value *, unsigned>;
 669
 670 private:
 671   /// TheModule - The module for which we are holding slot numbers.
 672   const Module* TheModule;
 673
 674   /// TheFunction - The function for which we are holding slot numbers.
 675   const Function* TheFunction = nullptr;
 676   bool FunctionProcessed = false;
 677   bool ShouldInitializeAllMetadata;
 678
 679   /// The summary index for which we are holding slot numbers.
 680   const ModuleSummaryIndex *TheIndex = nullptr;
 681
 682   /// mMap - The slot map for the module level data.
 683   ValueMap mMap;
 684   unsigned mNext = 0;
 685
 686   /// fMap - The slot map for the function level data.
 687   ValueMap fMap;
 688   unsigned fNext = 0;
 689
 690   /// mdnMap - Map for MDNodes.
 691   DenseMap<const MDNode*, unsigned> mdnMap;
 692   unsigned mdnNext = 0;
 693
 694   /// asMap - The slot map for attribute sets.
 695   DenseMap<AttributeSet, unsigned> asMap;
 696   unsigned asNext = 0;
 697
 698   /// ModulePathMap - The slot map for Module paths used in the summary index.
 699   StringMap<unsigned> ModulePathMap;
 700   unsigned ModulePathNext = 0;
 701
 702   /// GUIDMap - The slot map for GUIDs used in the summary index.
 703   DenseMap<GlobalValue::GUID, unsigned> GUIDMap;
 704   unsigned GUIDNext = 0;
 705
 706   /// TypeIdMap - The slot map for type ids used in the summary index.
 707   StringMap<unsigned> TypeIdMap;
 708   unsigned TypeIdNext = 0;
 709
 710 public:
 711   /// Construct from a module.
 712   ///
 713   /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
 714   /// functions, giving correct numbering for metadata referenced only from
 715   /// within a function (even if no functions have been initialized).
 716   explicit SlotTracker(const Module *M,
 717                        bool ShouldInitializeAllMetadata = false);
 718
 719   /// Construct from a function, starting out in incorp state.
 720   ///
 721   /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
 722   /// functions, giving correct numbering for metadata referenced only from
 723   /// within a function (even if no functions have been initialized).
 724   explicit SlotTracker(const Function *F,
 725                        bool ShouldInitializeAllMetadata = false);
 726
 727   /// Construct from a module summary index.
 728   explicit SlotTracker(const ModuleSummaryIndex *Index);
 729
 730   SlotTracker(const SlotTracker &) = delete;
 731   SlotTracker &operator=(const SlotTracker &) = delete;
 732
 733   /// Return the slot number of the specified value in it's type
 734   /// plane.  If something is not in the SlotTracker, return -1.
 735   int getLocalSlot(const Value *V);
 736   int getGlobalSlot(const GlobalValue *V);
 737   int getMetadataSlot(const MDNode *N);
 738   int getAttributeGroupSlot(AttributeSet AS);
 739   int getModulePathSlot(StringRef Path);
 740   int getGUIDSlot(GlobalValue::GUID GUID);
 741   int getTypeIdSlot(StringRef Id);
 742
 743   /// If you'd like to deal with a function instead of just a module, use
 744   /// this method to get its data into the SlotTracker.
 745   void incorporateFunction(const Function *F) {
 746     TheFunction = F;
 747     FunctionProcessed = false;
 748   }
 749
 750   const Function *getFunction() const { return TheFunction; }
 751
 752   /// After calling incorporateFunction, use this method to remove the
 753   /// most recently incorporated function from the SlotTracker. This
 754   /// will reset the state of the machine back to just the module contents.
 755   void purgeFunction();
 756
 757   /// MDNode map iterators.
 758   using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;
 759
 760   mdn_iterator mdn_begin() { return mdnMap.begin(); }
 761   mdn_iterator mdn_end() { return mdnMap.end(); }
 762   unsigned mdn_size() const { return mdnMap.size(); }
 763   bool mdn_empty() const { return mdnMap.empty(); }
 764
 765   /// AttributeSet map iterators.
 766   using as_iterator = DenseMap<AttributeSet, unsigned>::iterator;
 767
 768   as_iterator as_begin()   { return asMap.begin(); }
 769   as_iterator as_end()     { return asMap.end(); }
 770   unsigned as_size() const { return asMap.size(); }
 771   bool as_empty() const    { return asMap.empty(); }
 772
 773   /// GUID map iterators.
 774   using guid_iterator = DenseMap<GlobalValue::GUID, unsigned>::iterator;
 775
 776   /// These functions do the actual initialization.
 777   inline void initializeIfNeeded();
 778   void initializeIndexIfNeeded();
 779
 780   // Implementation Details
 781 private:
 782   /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
 783   void CreateModuleSlot(const GlobalValue *V);
 784
 785   /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
 786   void CreateMetadataSlot(const MDNode *N);
 787
 788   /// CreateFunctionSlot - Insert the specified Value* into the slot table.
 789   void CreateFunctionSlot(const Value *V);
 790
 791   /// Insert the specified AttributeSet into the slot table.
 792   void CreateAttributeSetSlot(AttributeSet AS);
 793
 794   inline void CreateModulePathSlot(StringRef Path);
 795   void CreateGUIDSlot(GlobalValue::GUID GUID);
 796   void CreateTypeIdSlot(StringRef Id);
 797
 798   /// Add all of the module level global variables (and their initializers)
 799   /// and function declarations, but not the contents of those functions.
 800   void processModule();
 801   void processIndex();
 802
 803   /// Add all of the functions arguments, basic blocks, and instructions.
 804   void processFunction();
 805
 806   /// Add the metadata directly attached to a GlobalObject.
 807   void processGlobalObjectMetadata(const GlobalObject &GO);
 808
 809   /// Add all of the metadata from a function.
 810   void processFunctionMetadata(const Function &F);
 811
 812   /// Add all of the metadata from an instruction.
 813   void processInstructionMetadata(const Instruction &I);
 814 };
 815
 816 } // end namespace llvm
 817
 818 ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
 819                                      const Function *F)
 820     : M(M), F(F), Machine(&Machine) {}
 821
 822 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
 823                                      bool ShouldInitializeAllMetadata)
 824     : ShouldCreateStorage(M),
 825       ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
 826
 827 ModuleSlotTracker::~ModuleSlotTracker() = default;
 828
 829 SlotTracker *ModuleSlotTracker::getMachine() {
 830   if (!ShouldCreateStorage)
 831     return Machine;
 832
 833   ShouldCreateStorage = false;
 834   MachineStorage =
 835       llvm::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
 836   Machine = MachineStorage.get();
 837   return Machine;
 838 }
 839
 840 void ModuleSlotTracker::incorporateFunction(const Function &F) {
 841   // Using getMachine() may lazily create the slot tracker.
 842   if (!getMachine())
 843     return;
 844
 845   // Nothing to do if this is the right function already.
 846   if (this->F == &F)
 847     return;
 848   if (this->F)
 849     Machine->purgeFunction();
 850   Machine->incorporateFunction(&F);
 851   this->F = &F;
 852 }
 853
 854 int ModuleSlotTracker::getLocalSlot(const Value *V) {
 855   assert(F && "No function incorporated");
 856   return Machine->getLocalSlot(V);
 857 }
 858
 859 static SlotTracker *createSlotTracker(const Value *V) {
 860   if (const Argument *FA = dyn_cast<Argument>(V))
 861     return new SlotTracker(FA->getParent());
 862
 863   if (const Instruction *I = dyn_cast<Instruction>(V))
 864     if (I->getParent())
 865       return new SlotTracker(I->getParent()->getParent());
 866
 867   if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
 868     return new SlotTracker(BB->getParent());
 869
 870   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
 871     return new SlotTracker(GV->getParent());
 872
 873   if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
 874     return new SlotTracker(GA->getParent());
 875
 876   if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
 877     return new SlotTracker(GIF->getParent());
 878
 879   if (const Function *Func = dyn_cast<Function>(V))
 880     return new SlotTracker(Func);
 881
 882   return nullptr;
 883 }
 884
 885 #if 0
 886 #define ST_DEBUG(X) dbgs() << X
 887 #else
 888 #define ST_DEBUG(X)
 889 #endif
 890
 891 // Module level constructor. Causes the contents of the Module (sans functions)
 892 // to be added to the slot table.
 893 SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
 894     : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
 895
 896 // Function level constructor. Causes the contents of the Module and the one
 897 // function provided to be added to the slot table.
 898 SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
 899     : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
 900       ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
 901
 902 SlotTracker::SlotTracker(const ModuleSummaryIndex *Index)
 903     : TheModule(nullptr), ShouldInitializeAllMetadata(false), TheIndex(Index) {}
 904
 905 inline void SlotTracker::initializeIfNeeded() {
 906   if (TheModule) {
 907     processModule();
 908     TheModule = nullptr; ///< Prevent re-processing next time we're called.
 909   }
 910
 911   if (TheFunction && !FunctionProcessed)
 912     processFunction();
 913 }
 914
 915 void SlotTracker::initializeIndexIfNeeded() {
 916   if (!TheIndex)
 917     return;
 918   processIndex();
 919   TheIndex = nullptr; ///< Prevent re-processing next time we're called.
 920 }
 921
 922 // Iterate through all the global variables, functions, and global
 923 // variable initializers and create slots for them.
 924 void SlotTracker::processModule() {
 925   ST_DEBUG("begin processModule!\n");
 926
 927   // Add all of the unnamed global variables to the value table.
 928   for (const GlobalVariable &Var : TheModule->globals()) {
 929     if (!Var.hasName())
 930       CreateModuleSlot(&Var);
 931     processGlobalObjectMetadata(Var);
 932     auto Attrs = Var.getAttributes();
 933     if (Attrs.hasAttributes())
 934       CreateAttributeSetSlot(Attrs);
 935   }
 936
 937   for (const GlobalAlias &A : TheModule->aliases()) {
 938     if (!A.hasName())
 939       CreateModuleSlot(&A);
 940   }
 941
 942   for (const GlobalIFunc &I : TheModule->ifuncs()) {
 943     if (!I.hasName())
 944       CreateModuleSlot(&I);
 945   }
 946
 947   // Add metadata used by named metadata.
 948   for (const NamedMDNode &NMD : TheModule->named_metadata()) {
 949     for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
 950       CreateMetadataSlot(NMD.getOperand(i));
 951   }
 952
 953   for (const Function &F : *TheModule) {
 954     if (!F.hasName())
 955       // Add all the unnamed functions to the table.
 956       CreateModuleSlot(&F);
 957
 958     if (ShouldInitializeAllMetadata)
 959       processFunctionMetadata(F);
 960
 961     // Add all the function attributes to the table.
 962     // FIXME: Add attributes of other objects?
 963     AttributeSet FnAttrs = F.getAttributes().getFnAttributes();
 964     if (FnAttrs.hasAttributes())
 965       CreateAttributeSetSlot(FnAttrs);
 966   }
 967
 968   ST_DEBUG("end processModule!\n");
 969 }
 970
 971 // Process the arguments, basic blocks, and instructions  of a function.
 972 void SlotTracker::processFunction() {
 973   ST_DEBUG("begin processFunction!\n");
 974   fNext = 0;
 975
 976   // Process function metadata if it wasn't hit at the module-level.
 977   if (!ShouldInitializeAllMetadata)
 978     processFunctionMetadata(*TheFunction);
 979
 980   // Add all the function arguments with no names.
 981   for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
 982       AE = TheFunction->arg_end(); AI != AE; ++AI)
 983     if (!AI->hasName())
 984       CreateFunctionSlot(&*AI);
 985
 986   ST_DEBUG("Inserting Instructions:\n");
 987
 988   // Add all of the basic blocks and instructions with no names.
 989   for (auto &BB : *TheFunction) {
 990     if (!BB.hasName())
 991       CreateFunctionSlot(&BB);
 992
 993     for (auto &I : BB) {
 994       if (!I.getType()->isVoidTy() && !I.hasName())
 995         CreateFunctionSlot(&I);
 996
 997       // We allow direct calls to any llvm.foo function here, because the
 998       // target may not be linked into the optimizer.
 999       if (const auto *Call = dyn_cast<CallBase>(&I)) {
1000         // Add all the call attributes to the table.
1001         AttributeSet Attrs = Call->getAttributes().getFnAttributes();
1002         if (Attrs.hasAttributes())
1003           CreateAttributeSetSlot(Attrs);
1004       }
1005     }
1006   }
1007
1008   FunctionProcessed = true;
1009
1010   ST_DEBUG("end processFunction!\n");
1011 }
1012
1013 // Iterate through all the GUID in the index and create slots for them.
1014 void SlotTracker::processIndex() {
1015   ST_DEBUG("begin processIndex!\n");
1016   assert(TheIndex);
1017
1018   // The first block of slots are just the module ids, which start at 0 and are
1019   // assigned consecutively. Since the StringMap iteration order isn't
1020   // guaranteed, use a std::map to order by module ID before assigning slots.
1021   std::map<uint64_t, StringRef> ModuleIdToPathMap;
1022   for (auto &ModPath : TheIndex->modulePaths())
1023     ModuleIdToPathMap[ModPath.second.first] = ModPath.first();
1024   for (auto &ModPair : ModuleIdToPathMap)
1025     CreateModulePathSlot(ModPair.second);
1026
1027   // Start numbering the GUIDs after the module ids.
1028   GUIDNext = ModulePathNext;
1029
1030   for (auto &GlobalList : *TheIndex)
1031     CreateGUIDSlot(GlobalList.first);
1032
1033   // Start numbering the TypeIds after the GUIDs.
1034   TypeIdNext = GUIDNext;
1035
1036   for (auto TidIter = TheIndex->typeIds().begin();
1037        TidIter != TheIndex->typeIds().end(); TidIter++)
1038     CreateTypeIdSlot(TidIter->second.first);
1039
1040   ST_DEBUG("end processIndex!\n");
1041 }
1042
1043 void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
1044   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
1045   GO.getAllMetadata(MDs);
1046   for (auto &MD : MDs)
1047     CreateMetadataSlot(MD.second);
1048 }
1049
1050 void SlotTracker::processFunctionMetadata(const Function &F) {
1051   processGlobalObjectMetadata(F);
1052   for (auto &BB : F) {
1053     for (auto &I : BB)
1054       processInstructionMetadata(I);
1055   }
1056 }
1057
1058 void SlotTracker::processInstructionMetadata(const Instruction &I) {
1059   // Process metadata used directly by intrinsics.
1060   if (const CallInst *CI = dyn_cast<CallInst>(&I))
1061     if (Function *F = CI->getCalledFunction())
1062       if (F->isIntrinsic())
1063         for (auto &Op : I.operands())
1064           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
1065             if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
1066               CreateMetadataSlot(N);
1067
1068   // Process metadata attached to this instruction.
1069   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
1070   I.getAllMetadata(MDs);
1071   for (auto &MD : MDs)
1072     CreateMetadataSlot(MD.second);
1073 }
1074
1075 /// Clean up after incorporating a function. This is the only way to get out of
1076 /// the function incorporation state that affects get*Slot/Create*Slot. Function
1077 /// incorporation state is indicated by TheFunction != 0.
1078 void SlotTracker::purgeFunction() {
1079   ST_DEBUG("begin purgeFunction!\n");
1080   fMap.clear(); // Simply discard the function level map
1081   TheFunction = nullptr;
1082   FunctionProcessed = false;
1083   ST_DEBUG("end purgeFunction!\n");
1084 }
1085
1086 /// getGlobalSlot - Get the slot number of a global value.
1087 int SlotTracker::getGlobalSlot(const GlobalValue *V) {
1088   // Check for uninitialized state and do lazy initialization.
1089   initializeIfNeeded();
1090
1091   // Find the value in the module map
1092   ValueMap::iterator MI = mMap.find(V);
1093   return MI == mMap.end() ? -1 : (int)MI->second;
1094 }
1095
1096 /// getMetadataSlot - Get the slot number of a MDNode.
1097 int SlotTracker::getMetadataSlot(const MDNode *N) {
1098   // Check for uninitialized state and do lazy initialization.
1099   initializeIfNeeded();
1100
1101   // Find the MDNode in the module map
1102   mdn_iterator MI = mdnMap.find(N);
1103   return MI == mdnMap.end() ? -1 : (int)MI->second;
1104 }
1105
1106 /// getLocalSlot - Get the slot number for a value that is local to a function.
1107 int SlotTracker::getLocalSlot(const Value *V) {
1108   assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
1109
1110   // Check for uninitialized state and do lazy initialization.
1111   initializeIfNeeded();
1112
1113   ValueMap::iterator FI = fMap.find(V);
1114   return FI == fMap.end() ? -1 : (int)FI->second;
1115 }
1116
1117 int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
1118   // Check for uninitialized state and do lazy initialization.
1119   initializeIfNeeded();
1120
1121   // Find the AttributeSet in the module map.
1122   as_iterator AI = asMap.find(AS);
1123   return AI == asMap.end() ? -1 : (int)AI->second;
1124 }
1125
1126 int SlotTracker::getModulePathSlot(StringRef Path) {
1127   // Check for uninitialized state and do lazy initialization.
1128   initializeIndexIfNeeded();
1129
1130   // Find the Module path in the map
1131   auto I = ModulePathMap.find(Path);
1132   return I == ModulePathMap.end() ? -1 : (int)I->second;
1133 }
1134
1135 int SlotTracker::getGUIDSlot(GlobalValue::GUID GUID) {
1136   // Check for uninitialized state and do lazy initialization.
1137   initializeIndexIfNeeded();
1138
1139   // Find the GUID in the map
1140   guid_iterator I = GUIDMap.find(GUID);
1141   return I == GUIDMap.end() ? -1 : (int)I->second;
1142 }
1143
1144 int SlotTracker::getTypeIdSlot(StringRef Id) {
1145   // Check for uninitialized state and do lazy initialization.
1146   initializeIndexIfNeeded();
1147
1148   // Find the TypeId string in the map
1149   auto I = TypeIdMap.find(Id);
1150   return I == TypeIdMap.end() ? -1 : (int)I->second;
1151 }
1152
1153 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
1154 void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
1155   assert(V && "Can't insert a null Value into SlotTracker!");
1156   assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
1157   assert(!V->hasName() && "Doesn't need a slot!");
1158
1159   unsigned DestSlot = mNext++;
1160   mMap[V] = DestSlot;
1161
1162   ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1163            DestSlot << " [");
1164   // G = Global, F = Function, A = Alias, I = IFunc, o = other
1165   ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
1166             (isa<Function>(V) ? 'F' :
1167              (isa<GlobalAlias>(V) ? 'A' :
1168               (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
1169 }
1170
1171 /// CreateSlot - Create a new slot for the specified value if it has no name.
1172 void SlotTracker::CreateFunctionSlot(const Value *V) {
1173   assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
1174
1175   unsigned DestSlot = fNext++;
1176   fMap[V] = DestSlot;
1177
1178   // G = Global, F = Function, o = other
1179   ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1180            DestSlot << " [o]\n");
1181 }
1182
1183 /// CreateModuleSlot - Insert the specified MDNode* into the slot table.
1184 void SlotTracker::CreateMetadataSlot(const MDNode *N) {
1185   assert(N && "Can't insert a null Value into SlotTracker!");
1186
1187   // Don't make slots for DIExpressions. We just print them inline everywhere.
1188   if (isa<DIExpression>(N))
1189     return;
1190
1191   unsigned DestSlot = mdnNext;
1192   if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1193     return;
1194   ++mdnNext;
1195
1196   // Recursively add any MDNodes referenced by operands.
1197   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
1198     if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1199       CreateMetadataSlot(Op);
1200 }
1201
1202 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
1203   assert(AS.hasAttributes() && "Doesn't need a slot!");
1204
1205   as_iterator I = asMap.find(AS);
1206   if (I != asMap.end())
1207     return;
1208
1209   unsigned DestSlot = asNext++;
1210   asMap[AS] = DestSlot;
1211 }
1212
1213 /// Create a new slot for the specified Module
1214 void SlotTracker::CreateModulePathSlot(StringRef Path) {
1215   ModulePathMap[Path] = ModulePathNext++;
1216 }
1217
1218 /// Create a new slot for the specified GUID
1219 void SlotTracker::CreateGUIDSlot(GlobalValue::GUID GUID) {
1220   GUIDMap[GUID] = GUIDNext++;
1221 }
1222
1223 /// Create a new slot for the specified Id
1224 void SlotTracker::CreateTypeIdSlot(StringRef Id) {
1225   TypeIdMap[Id] = TypeIdNext++;
1226 }
1227
1228 //===----------------------------------------------------------------------===//
1229 // AsmWriter Implementation
1230 //===----------------------------------------------------------------------===//
1231
1232 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1233                                    TypePrinting *TypePrinter,
1234                                    SlotTracker *Machine,
1235                                    const Module *Context);
1236
1237 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1238                                    TypePrinting *TypePrinter,
1239                                    SlotTracker *Machine, const Module *Context,
1240                                    bool FromValue = false);
1241
1242 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
1243   if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
1244     // 'Fast' is an abbreviation for all fast-math-flags.
1245     if (FPO->isFast())
1246       Out << " fast";
1247     else {
1248       if (FPO->hasAllowReassoc())
1249         Out << " reassoc";
1250       if (FPO->hasNoNaNs())
1251         Out << " nnan";
1252       if (FPO->hasNoInfs())
1253         Out << " ninf";
1254       if (FPO->hasNoSignedZeros())
1255         Out << " nsz";
1256       if (FPO->hasAllowReciprocal())
1257         Out << " arcp";
1258       if (FPO->hasAllowContract())
1259         Out << " contract";
1260       if (FPO->hasApproxFunc())
1261         Out << " afn";
1262     }
1263   }
1264
1265   if (const OverflowingBinaryOperator *OBO =
1266         dyn_cast<OverflowingBinaryOperator>(U)) {
1267     if (OBO->hasNoUnsignedWrap())
1268       Out << " nuw";
1269     if (OBO->hasNoSignedWrap())
1270       Out << " nsw";
1271   } else if (const PossiblyExactOperator *Div =
1272                dyn_cast<PossiblyExactOperator>(U)) {
1273     if (Div->isExact())
1274       Out << " exact";
1275   } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
1276     if (GEP->isInBounds())
1277       Out << " inbounds";
1278   }
1279 }
1280
1281 static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
1282                                   TypePrinting &TypePrinter,
1283                                   SlotTracker *Machine,
1284                                   const Module *Context) {
1285   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1286     if (CI->getType()->isIntegerTy(1)) {
1287       Out << (CI->getZExtValue() ? "true" : "false");
1288       return;
1289     }
1290     Out << CI->getValue();
1291     return;
1292   }
1293
1294   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1295     const APFloat &APF = CFP->getValueAPF();
1296     if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1297         &APF.getSemantics() == &APFloat::IEEEdouble()) {
1298       // We would like to output the FP constant value in exponential notation,
1299       // but we cannot do this if doing so will lose precision.  Check here to
1300       // make sure that we only output it in exponential format if we can parse
1301       // the value back and get the same value.
1302       //
1303       bool ignored;
1304       bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1305       bool isInf = APF.isInfinity();
1306       bool isNaN = APF.isNaN();
1307       if (!isInf && !isNaN) {
1308         double Val = isDouble ? APF.convertToDouble() : APF.convertToFloat();
1309         SmallString<128> StrVal;
1310         APF.toString(StrVal, 6, 0, false);
1311         // Check to make sure that the stringized number is not some string like
1312         // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
1313         // that the string matches the "[-+]?[0-9]" regex.
1314         //
1315         assert(((StrVal[0] >= '0' && StrVal[0] <= '9') ||
1316                 ((StrVal[0] == '-' || StrVal[0] == '+') &&
1317                  (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
1318                "[-+]?[0-9] regex does not match!");
1319         // Reparse stringized version!
1320         if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1321           Out << StrVal;
1322           return;
1323         }
1324       }
1325       // Otherwise we could not reparse it to exactly the same value, so we must
1326       // output the string in hexadecimal format!  Note that loading and storing
1327       // floating point types changes the bits of NaNs on some hosts, notably
1328       // x86, so we must not use these types.
1329       static_assert(sizeof(double) == sizeof(uint64_t),
1330                     "assuming that double is 64 bits!");
1331       APFloat apf = APF;
1332       // Floats are represented in ASCII IR as double, convert.
1333       if (!isDouble)
1334         apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
1335                           &ignored);
1336       Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1337       return;
1338     }
1339
1340     // Either half, or some form of long double.
1341     // These appear as a magic letter identifying the type, then a
1342     // fixed number of hex digits.
1343     Out << "0x";
1344     APInt API = APF.bitcastToAPInt();
1345     if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1346       Out << 'K';
1347       Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1348                                   /*Upper=*/true);
1349       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1350                                   /*Upper=*/true);
1351       return;
1352     } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1353       Out << 'L';
1354       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1355                                   /*Upper=*/true);
1356       Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1357                                   /*Upper=*/true);
1358     } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1359       Out << 'M';
1360       Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1361                                   /*Upper=*/true);
1362       Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1363                                   /*Upper=*/true);
1364     } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
1365       Out << 'H';
1366       Out << format_hex_no_prefix(API.getZExtValue(), 4,
1367                                   /*Upper=*/true);
1368     } else
1369       llvm_unreachable("Unsupported floating point type");
1370     return;
1371   }
1372
1373   if (isa<ConstantAggregateZero>(CV)) {
1374     Out << "zeroinitializer";
1375     return;
1376   }
1377
1378   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1379     Out << "blockaddress(";
1380     WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
1381                            Context);
1382     Out << ", ";
1383     WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
1384                            Context);
1385     Out << ")";
1386     return;
1387   }
1388
1389   if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1390     Type *ETy = CA->getType()->getElementType();
1391     Out << '[';
1392     TypePrinter.print(ETy, Out);
1393     Out << ' ';
1394     WriteAsOperandInternal(Out, CA->getOperand(0),
1395                            &TypePrinter, Machine,
1396                            Context);
1397     for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
1398       Out << ", ";
1399       TypePrinter.print(ETy, Out);
1400       Out << ' ';
1401       WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
1402                              Context);
1403     }
1404     Out << ']';
1405     return;
1406   }
1407
1408   if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
1409     // As a special case, print the array as a string if it is an array of
1410     // i8 with ConstantInt values.
1411     if (CA->isString()) {
1412       Out << "c\"";
1413       printEscapedString(CA->getAsString(), Out);
1414       Out << '"';
1415       return;
1416     }
1417
1418     Type *ETy = CA->getType()->getElementType();
1419     Out << '[';
1420     TypePrinter.print(ETy, Out);
1421     Out << ' ';
1422     WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
1423                            &TypePrinter, Machine,
1424                            Context);
1425     for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
1426       Out << ", ";
1427       TypePrinter.print(ETy, Out);
1428       Out << ' ';
1429       WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
1430                              Machine, Context);
1431     }
1432     Out << ']';
1433     return;
1434   }
1435
1436   if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
1437     if (CS->getType()->isPacked())
1438       Out << '<';
1439     Out << '{';
1440     unsigned N = CS->getNumOperands();
1441     if (N) {
1442       Out << ' ';
1443       TypePrinter.print(CS->getOperand(0)->getType(), Out);
1444       Out << ' ';
1445
1446       WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
1447                              Context);
1448
1449       for (unsigned i = 1; i < N; i++) {
1450         Out << ", ";
1451         TypePrinter.print(CS->getOperand(i)->getType(), Out);
1452         Out << ' ';
1453
1454         WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
1455                                Context);
1456       }
1457       Out << ' ';
1458     }
1459
1460     Out << '}';
1461     if (CS->getType()->isPacked())
1462       Out << '>';
1463     return;
1464   }
1465
1466   if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
1467     Type *ETy = CV->getType()->getVectorElementType();
1468     Out << '<';
1469     TypePrinter.print(ETy, Out);
1470     Out << ' ';
1471     WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
1472                            Machine, Context);
1473     for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
1474       Out << ", ";
1475       TypePrinter.print(ETy, Out);
1476       Out << ' ';
1477       WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
1478                              Machine, Context);
1479     }
1480     Out << '>';
1481     return;
1482   }
1483
1484   if (isa<ConstantPointerNull>(CV)) {
1485     Out << "null";
1486     return;
1487   }
1488
1489   if (isa<ConstantTokenNone>(CV)) {
1490     Out << "none";
1491     return;
1492   }
1493
1494   if (isa<UndefValue>(CV)) {
1495     Out << "undef";
1496     return;
1497   }
1498
1499   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1500     Out << CE->getOpcodeName();
1501     WriteOptimizationInfo(Out, CE);
1502     if (CE->isCompare())
1503       Out << ' ' << CmpInst::getPredicateName(
1504                         static_cast<CmpInst::Predicate>(CE->getPredicate()));
1505     Out << " (";
1506
1507     Optional<unsigned> InRangeOp;
1508     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1509       TypePrinter.print(GEP->getSourceElementType(), Out);
1510       Out << ", ";
1511       InRangeOp = GEP->getInRangeIndex();
1512       if (InRangeOp)
1513         ++*InRangeOp;
1514     }
1515
1516     for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
1517       if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
1518         Out << "inrange ";
1519       TypePrinter.print((*OI)->getType(), Out);
1520       Out << ' ';
1521       WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
1522       if (OI+1 != CE->op_end())
1523         Out << ", ";
1524     }
1525
1526     if (CE->hasIndices()) {
1527       ArrayRef<unsigned> Indices = CE->getIndices();
1528       for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1529         Out << ", " << Indices[i];
1530     }
1531
1532     if (CE->isCast()) {
1533       Out << " to ";
1534       TypePrinter.print(CE->getType(), Out);
1535     }
1536
1537     Out << ')';
1538     return;
1539   }
1540
1541   Out << "<placeholder or erroneous Constant>";
1542 }
1543
1544 static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1545                          TypePrinting *TypePrinter, SlotTracker *Machine,
1546                          const Module *Context) {
1547   Out << "!{";
1548   for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
1549     const Metadata *MD = Node->getOperand(mi);
1550     if (!MD)
1551       Out << "null";
1552     else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1553       Value *V = MDV->getValue();
1554       TypePrinter->print(V->getType(), Out);
1555       Out << ' ';
1556       WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
1557     } else {
1558       WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1559     }
1560     if (mi + 1 != me)
1561       Out << ", ";
1562   }
1563
1564   Out << "}";
1565 }
1566
1567 namespace {
1568
1569 struct FieldSeparator {
1570   bool Skip = true;
1571   const char *Sep;
1572
1573   FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
1574 };
1575
1576 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
1577   if (FS.Skip) {
1578     FS.Skip = false;
1579     return OS;
1580   }
1581   return OS << FS.Sep;
1582 }
1583
1584 struct MDFieldPrinter {
1585   raw_ostream &Out;
1586   FieldSeparator FS;
1587   TypePrinting *TypePrinter = nullptr;
1588   SlotTracker *Machine = nullptr;
1589   const Module *Context = nullptr;
1590
1591   explicit MDFieldPrinter(raw_ostream &Out) : Out(Out) {}
1592   MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
1593                  SlotTracker *Machine, const Module *Context)
1594       : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
1595   }
1596
1597   void printTag(const DINode *N);
1598   void printMacinfoType(const DIMacroNode *N);
1599   void printChecksum(const DIFile::ChecksumInfo<StringRef> &N);
1600   void printString(StringRef Name, StringRef Value,
1601                    bool ShouldSkipEmpty = true);
1602   void printMetadata(StringRef Name, const Metadata *MD,
1603                      bool ShouldSkipNull = true);
1604   template <class IntTy>
1605   void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1606   void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
1607   void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1608   void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
1609   template <class IntTy, class Stringifier>
1610   void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1611                       bool ShouldSkipZero = true);
1612   void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1613   void printNameTableKind(StringRef Name,
1614                           DICompileUnit::DebugNameTableKind NTK);
1615 };
1616
1617 } // end anonymous namespace
1618
1619 void MDFieldPrinter::printTag(const DINode *N) {
1620   Out << FS << "tag: ";
1621   auto Tag = dwarf::TagString(N->getTag());
1622   if (!Tag.empty())
1623     Out << Tag;
1624   else
1625     Out << N->getTag();
1626 }
1627
1628 void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1629   Out << FS << "type: ";
1630   auto Type = dwarf::MacinfoString(N->getMacinfoType());
1631   if (!Type.empty())
1632     Out << Type;
1633   else
1634     Out << N->getMacinfoType();
1635 }
1636
1637 void MDFieldPrinter::printChecksum(
1638     const DIFile::ChecksumInfo<StringRef> &Checksum) {
1639   Out << FS << "checksumkind: " << Checksum.getKindAsString();
1640   printString("checksum", Checksum.Value, /* ShouldSkipEmpty */ false);
1641 }
1642
1643 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1644                                  bool ShouldSkipEmpty) {
1645   if (ShouldSkipEmpty && Value.empty())
1646     return;
1647
1648   Out << FS << Name << ": \"";
1649   printEscapedString(Value, Out);
1650   Out << "\"";
1651 }
1652
1653 static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1654                                    TypePrinting *TypePrinter,
1655                                    SlotTracker *Machine,
1656                                    const Module *Context) {
1657   if (!MD) {
1658     Out << "null";
1659     return;
1660   }
1661   WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1662 }
1663
1664 void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1665                                    bool ShouldSkipNull) {
1666   if (ShouldSkipNull && !MD)
1667     return;
1668
1669   Out << FS << Name << ": ";
1670   writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1671 }
1672
1673 template <class IntTy>
1674 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1675   if (ShouldSkipZero && !Int)
1676     return;
1677
1678   Out << FS << Name << ": " << Int;
1679 }
1680
1681 void MDFieldPrinter::printBool(StringRef Name, bool Value,
1682                                Optional<bool> Default) {
1683   if (Default && Value == *Default)
1684     return;
1685   Out << FS << Name << ": " << (Value ? "true" : "false");
1686 }
1687
1688 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1689   if (!Flags)
1690     return;
1691
1692   Out << FS << Name << ": ";
1693
1694   SmallVector<DINode::DIFlags, 8> SplitFlags;
1695   auto Extra = DINode::splitFlags(Flags, SplitFlags);
1696
1697   FieldSeparator FlagsFS(" | ");
1698   for (auto F : SplitFlags) {
1699     auto StringF = DINode::getFlagString(F);
1700     assert(!StringF.empty() && "Expected valid flag");
1701     Out << FlagsFS << StringF;
1702   }
1703   if (Extra || SplitFlags.empty())
1704     Out << FlagsFS << Extra;
1705 }
1706
1707 void MDFieldPrinter::printDISPFlags(StringRef Name,
1708                                     DISubprogram::DISPFlags Flags) {
1709   // Always print this field, because no flags in the IR at all will be
1710   // interpreted as old-style isDefinition: true.
1711   Out << FS << Name << ": ";
1712
1713   if (!Flags) {
1714     Out << 0;
1715     return;
1716   }
1717
1718   SmallVector<DISubprogram::DISPFlags, 8> SplitFlags;
1719   auto Extra = DISubprogram::splitFlags(Flags, SplitFlags);
1720
1721   FieldSeparator FlagsFS(" | ");
1722   for (auto F : SplitFlags) {
1723     auto StringF = DISubprogram::getFlagString(F);
1724     assert(!StringF.empty() && "Expected valid flag");
1725     Out << FlagsFS << StringF;
1726   }
1727   if (Extra || SplitFlags.empty())
1728     Out << FlagsFS << Extra;
1729 }
1730
1731 void MDFieldPrinter::printEmissionKind(StringRef Name,
1732                                        DICompileUnit::DebugEmissionKind EK) {
1733   Out << FS << Name << ": " << DICompileUnit::emissionKindString(EK);
1734 }
1735
1736 void MDFieldPrinter::printNameTableKind(StringRef Name,
1737                                         DICompileUnit::DebugNameTableKind NTK) {
1738   if (NTK == DICompileUnit::DebugNameTableKind::Default)
1739     return;
1740   Out << FS << Name << ": " << DICompileUnit::nameTableKindString(NTK);
1741 }
1742
1743 template <class IntTy, class Stringifier>
1744 void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
1745                                     Stringifier toString, bool ShouldSkipZero) {
1746   if (!Value)
1747     return;
1748
1749   Out << FS << Name << ": ";
1750   auto S = toString(Value);
1751   if (!S.empty())
1752     Out << S;
1753   else
1754     Out << Value;
1755 }
1756
1757 static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
1758                                TypePrinting *TypePrinter, SlotTracker *Machine,
1759                                const Module *Context) {
1760   Out << "!GenericDINode(";
1761   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1762   Printer.printTag(N);
1763   Printer.printString("header", N->getHeader());
1764   if (N->getNumDwarfOperands()) {
1765     Out << Printer.FS << "operands: {";
1766     FieldSeparator IFS;
1767     for (auto &I : N->dwarf_operands()) {
1768       Out << IFS;
1769       writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
1770     }
1771     Out << "}";
1772   }
1773   Out << ")";
1774 }
1775
1776 static void writeDILocation(raw_ostream &Out, const DILocation *DL,
1777                             TypePrinting *TypePrinter, SlotTracker *Machine,
1778                             const Module *Context) {
1779   Out << "!DILocation(";
1780   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1781   // Always output the line, since 0 is a relevant and important value for it.
1782   Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
1783   Printer.printInt("column", DL->getColumn());
1784   Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
1785   Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
1786   Printer.printBool("isImplicitCode", DL->isImplicitCode(),
1787                     /* Default */ false);
1788   Out << ")";
1789 }
1790
1791 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
1792                             TypePrinting *TypePrinter, SlotTracker *Machine,
1793                             const Module *Context) {
1794   Out << "!DISubrange(";
1795   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1796   if (auto *CE = N->getCount().dyn_cast<ConstantInt*>())
1797     Printer.printInt("count", CE->getSExtValue(), /* ShouldSkipZero */ false);
1798   else
1799     Printer.printMetadata("count", N->getCount().dyn_cast<DIVariable*>(),
1800                           /*ShouldSkipNull */ false);
1801   Printer.printInt("lowerBound", N->getLowerBound());
1802   Out << ")";
1803 }
1804
1805 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
1806                               TypePrinting *, SlotTracker *, const Module *) {
1807   Out << "!DIEnumerator(";
1808   MDFieldPrinter Printer(Out);
1809   Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
1810   if (N->isUnsigned()) {
1811     auto Value = static_cast<uint64_t>(N->getValue());
1812     Printer.printInt("value", Value, /* ShouldSkipZero */ false);
1813     Printer.printBool("isUnsigned", true);
1814   } else {
1815     Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
1816   }
1817   Out << ")";
1818 }
1819
1820 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
1821                              TypePrinting *, SlotTracker *, const Module *) {
1822   Out << "!DIBasicType(";
1823   MDFieldPrinter Printer(Out);
1824   if (N->getTag() != dwarf::DW_TAG_base_type)
1825     Printer.printTag(N);
1826   Printer.printString("name", N->getName());
1827   Printer.printInt("size", N->getSizeInBits());
1828   Printer.printInt("align", N->getAlignInBits());
1829   Printer.printDwarfEnum("encoding", N->getEncoding(),
1830                          dwarf::AttributeEncodingString);
1831   Printer.printDIFlags("flags", N->getFlags());
1832   Out << ")";
1833 }
1834
1835 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
1836                                TypePrinting *TypePrinter, SlotTracker *Machine,
1837                                const Module *Context) {
1838   Out << "!DIDerivedType(";
1839   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1840   Printer.printTag(N);
1841   Printer.printString("name", N->getName());
1842   Printer.printMetadata("scope", N->getRawScope());
1843   Printer.printMetadata("file", N->getRawFile());
1844   Printer.printInt("line", N->getLine());
1845   Printer.printMetadata("baseType", N->getRawBaseType(),
1846                         /* ShouldSkipNull */ false);
1847   Printer.printInt("size", N->getSizeInBits());
1848   Printer.printInt("align", N->getAlignInBits());
1849   Printer.printInt("offset", N->getOffsetInBits());
1850   Printer.printDIFlags("flags", N->getFlags());
1851   Printer.printMetadata("extraData", N->getRawExtraData());
1852   if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
1853     Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
1854                      /* ShouldSkipZero */ false);
1855   Out << ")";
1856 }
1857
1858 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
1859                                  TypePrinting *TypePrinter,
1860                                  SlotTracker *Machine, const Module *Context) {
1861   Out << "!DICompositeType(";
1862   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1863   Printer.printTag(N);
1864   Printer.printString("name", N->getName());
1865   Printer.printMetadata("scope", N->getRawScope());
1866   Printer.printMetadata("file", N->getRawFile());
1867   Printer.printInt("line", N->getLine());
1868   Printer.printMetadata("baseType", N->getRawBaseType());
1869   Printer.printInt("size", N->getSizeInBits());
1870   Printer.printInt("align", N->getAlignInBits());
1871   Printer.printInt("offset", N->getOffsetInBits());
1872   Printer.printDIFlags("flags", N->getFlags());
1873   Printer.printMetadata("elements", N->getRawElements());
1874   Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
1875                          dwarf::LanguageString);
1876   Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
1877   Printer.printMetadata("templateParams", N->getRawTemplateParams());
1878   Printer.printString("identifier", N->getIdentifier());
1879   Printer.printMetadata("discriminator", N->getRawDiscriminator());
1880   Out << ")";
1881 }
1882
1883 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
1884                                   TypePrinting *TypePrinter,
1885                                   SlotTracker *Machine, const Module *Context) {
1886   Out << "!DISubroutineType(";
1887   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1888   Printer.printDIFlags("flags", N->getFlags());
1889   Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
1890   Printer.printMetadata("types", N->getRawTypeArray(),
1891                         /* ShouldSkipNull */ false);
1892   Out << ")";
1893 }
1894
1895 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
1896                         SlotTracker *, const Module *) {
1897   Out << "!DIFile(";
1898   MDFieldPrinter Printer(Out);
1899   Printer.printString("filename", N->getFilename(),
1900                       /* ShouldSkipEmpty */ false);
1901   Printer.printString("directory", N->getDirectory(),
1902                       /* ShouldSkipEmpty */ false);
1903   // Print all values for checksum together, or not at all.
1904   if (N->getChecksum())
1905     Printer.printChecksum(*N->getChecksum());
1906   Printer.printString("source", N->getSource().getValueOr(StringRef()),
1907                       /* ShouldSkipEmpty */ true);
1908   Out << ")";
1909 }
1910
1911 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
1912                                TypePrinting *TypePrinter, SlotTracker *Machine,
1913                                const Module *Context) {
1914   Out << "!DICompileUnit(";
1915   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1916   Printer.printDwarfEnum("language", N->getSourceLanguage(),
1917                          dwarf::LanguageString, /* ShouldSkipZero */ false);
1918   Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1919   Printer.printString("producer", N->getProducer());
1920   Printer.printBool("isOptimized", N->isOptimized());
1921   Printer.printString("flags", N->getFlags());
1922   Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
1923                    /* ShouldSkipZero */ false);
1924   Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
1925   Printer.printEmissionKind("emissionKind", N->getEmissionKind());
1926   Printer.printMetadata("enums", N->getRawEnumTypes());
1927   Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
1928   Printer.printMetadata("globals", N->getRawGlobalVariables());
1929   Printer.printMetadata("imports", N->getRawImportedEntities());
1930   Printer.printMetadata("macros", N->getRawMacros());
1931   Printer.printInt("dwoId", N->getDWOId());
1932   Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
1933   Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
1934                     false);
1935   Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
1936   Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
1937   Out << ")";
1938 }
1939
1940 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
1941                               TypePrinting *TypePrinter, SlotTracker *Machine,
1942                               const Module *Context) {
1943   Out << "!DISubprogram(";
1944   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1945   Printer.printString("name", N->getName());
1946   Printer.printString("linkageName", N->getLinkageName());
1947   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1948   Printer.printMetadata("file", N->getRawFile());
1949   Printer.printInt("line", N->getLine());
1950   Printer.printMetadata("type", N->getRawType());
1951   Printer.printInt("scopeLine", N->getScopeLine());
1952   Printer.printMetadata("containingType", N->getRawContainingType());
1953   if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
1954       N->getVirtualIndex() != 0)
1955     Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
1956   Printer.printInt("thisAdjustment", N->getThisAdjustment());
1957   Printer.printDIFlags("flags", N->getFlags());
1958   Printer.printDISPFlags("spFlags", N->getSPFlags());
1959   Printer.printMetadata("unit", N->getRawUnit());
1960   Printer.printMetadata("templateParams", N->getRawTemplateParams());
1961   Printer.printMetadata("declaration", N->getRawDeclaration());
1962   Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
1963   Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
1964   Out << ")";
1965 }
1966
1967 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
1968                                 TypePrinting *TypePrinter, SlotTracker *Machine,
1969                                 const Module *Context) {
1970   Out << "!DILexicalBlock(";
1971   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1972   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1973   Printer.printMetadata("file", N->getRawFile());
1974   Printer.printInt("line", N->getLine());
1975   Printer.printInt("column", N->getColumn());
1976   Out << ")";
1977 }
1978
1979 static void writeDILexicalBlockFile(raw_ostream &Out,
1980                                     const DILexicalBlockFile *N,
1981                                     TypePrinting *TypePrinter,
1982                                     SlotTracker *Machine,
1983                                     const Module *Context) {
1984   Out << "!DILexicalBlockFile(";
1985   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1986   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1987   Printer.printMetadata("file", N->getRawFile());
1988   Printer.printInt("discriminator", N->getDiscriminator(),
1989                    /* ShouldSkipZero */ false);
1990   Out << ")";
1991 }
1992
1993 static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
1994                              TypePrinting *TypePrinter, SlotTracker *Machine,
1995                              const Module *Context) {
1996   Out << "!DINamespace(";
1997   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1998   Printer.printString("name", N->getName());
1999   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2000   Printer.printBool("exportSymbols", N->getExportSymbols(), false);
2001   Out << ")";
2002 }
2003
2004 static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N,
2005                                TypePrinting *TypePrinter, SlotTracker *Machine,
2006                                const Module *Context) {
2007   Out << "!DICommonBlock(";
2008   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2009   Printer.printMetadata("scope", N->getRawScope(), false);
2010   Printer.printMetadata("declaration", N->getRawDecl(), false);
2011   Printer.printString("name", N->getName());
2012   Printer.printMetadata("file", N->getRawFile());
2013   Printer.printInt("line", N->getLineNo());
2014   Out << ")";
2015 }
2016
2017 static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
2018                          TypePrinting *TypePrinter, SlotTracker *Machine,
2019                          const Module *Context) {
2020   Out << "!DIMacro(";
2021   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2022   Printer.printMacinfoType(N);
2023   Printer.printInt("line", N->getLine());
2024   Printer.printString("name", N->getName());
2025   Printer.printString("value", N->getValue());
2026   Out << ")";
2027 }
2028
2029 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
2030                              TypePrinting *TypePrinter, SlotTracker *Machine,
2031                              const Module *Context) {
2032   Out << "!DIMacroFile(";
2033   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2034   Printer.printInt("line", N->getLine());
2035   Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2036   Printer.printMetadata("nodes", N->getRawElements());
2037   Out << ")";
2038 }
2039
2040 static void writeDIModule(raw_ostream &Out, const DIModule *N,
2041                           TypePrinting *TypePrinter, SlotTracker *Machine,
2042                           const Module *Context) {
2043   Out << "!DIModule(";
2044   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2045   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2046   Printer.printString("name", N->getName());
2047   Printer.printString("configMacros", N->getConfigurationMacros());
2048   Printer.printString("includePath", N->getIncludePath());
2049   Printer.printString("isysroot", N->getISysRoot());
2050   Out << ")";
2051 }
2052
2053
2054 static void writeDITemplateTypeParameter(raw_ostream &Out,
2055                                          const DITemplateTypeParameter *N,
2056                                          TypePrinting *TypePrinter,
2057                                          SlotTracker *Machine,
2058                                          const Module *Context) {
2059   Out << "!DITemplateTypeParameter(";
2060   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2061   Printer.printString("name", N->getName());
2062   Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
2063   Out << ")";
2064 }
2065
2066 static void writeDITemplateValueParameter(raw_ostream &Out,
2067                                           const DITemplateValueParameter *N,
2068                                           TypePrinting *TypePrinter,
2069                                           SlotTracker *Machine,
2070                                           const Module *Context) {
2071   Out << "!DITemplateValueParameter(";
2072   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2073   if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
2074     Printer.printTag(N);
2075   Printer.printString("name", N->getName());
2076   Printer.printMetadata("type", N->getRawType());
2077   Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
2078   Out << ")";
2079 }
2080
2081 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
2082                                   TypePrinting *TypePrinter,
2083                                   SlotTracker *Machine, const Module *Context) {
2084   Out << "!DIGlobalVariable(";
2085   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2086   Printer.printString("name", N->getName());
2087   Printer.printString("linkageName", N->getLinkageName());
2088   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2089   Printer.printMetadata("file", N->getRawFile());
2090   Printer.printInt("line", N->getLine());
2091   Printer.printMetadata("type", N->getRawType());
2092   Printer.printBool("isLocal", N->isLocalToUnit());
2093   Printer.printBool("isDefinition", N->isDefinition());
2094   Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
2095   Printer.printMetadata("templateParams", N->getRawTemplateParams());
2096   Printer.printInt("align", N->getAlignInBits());
2097   Out << ")";
2098 }
2099
2100 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
2101                                  TypePrinting *TypePrinter,
2102                                  SlotTracker *Machine, const Module *Context) {
2103   Out << "!DILocalVariable(";
2104   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2105   Printer.printString("name", N->getName());
2106   Printer.printInt("arg", N->getArg());
2107   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2108   Printer.printMetadata("file", N->getRawFile());
2109   Printer.printInt("line", N->getLine());
2110   Printer.printMetadata("type", N->getRawType());
2111   Printer.printDIFlags("flags", N->getFlags());
2112   Printer.printInt("align", N->getAlignInBits());
2113   Out << ")";
2114 }
2115
2116 static void writeDILabel(raw_ostream &Out, const DILabel *N,
2117                          TypePrinting *TypePrinter,
2118                          SlotTracker *Machine, const Module *Context) {
2119   Out << "!DILabel(";
2120   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2121   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2122   Printer.printString("name", N->getName());
2123   Printer.printMetadata("file", N->getRawFile());
2124   Printer.printInt("line", N->getLine());
2125   Out << ")";
2126 }
2127
2128 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
2129                               TypePrinting *TypePrinter, SlotTracker *Machine,
2130                               const Module *Context) {
2131   Out << "!DIExpression(";
2132   FieldSeparator FS;
2133   if (N->isValid()) {
2134     for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
2135       auto OpStr = dwarf::OperationEncodingString(I->getOp());
2136       assert(!OpStr.empty() && "Expected valid opcode");
2137
2138       Out << FS << OpStr;
2139       if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
2140         Out << FS << I->getArg(0);
2141         Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
2142       } else {
2143         for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
2144           Out << FS << I->getArg(A);
2145       }
2146     }
2147   } else {
2148     for (const auto &I : N->getElements())
2149       Out << FS << I;
2150   }
2151   Out << ")";
2152 }
2153
2154 static void writeDIGlobalVariableExpression(raw_ostream &Out,
2155                                             const DIGlobalVariableExpression *N,
2156                                             TypePrinting *TypePrinter,
2157                                             SlotTracker *Machine,
2158                                             const Module *Context) {
2159   Out << "!DIGlobalVariableExpression(";
2160   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2161   Printer.printMetadata("var", N->getVariable());
2162   Printer.printMetadata("expr", N->getExpression());
2163   Out << ")";
2164 }
2165
2166 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
2167                                 TypePrinting *TypePrinter, SlotTracker *Machine,
2168                                 const Module *Context) {
2169   Out << "!DIObjCProperty(";
2170   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2171   Printer.printString("name", N->getName());
2172   Printer.printMetadata("file", N->getRawFile());
2173   Printer.printInt("line", N->getLine());
2174   Printer.printString("setter", N->getSetterName());
2175   Printer.printString("getter", N->getGetterName());
2176   Printer.printInt("attributes", N->getAttributes());
2177   Printer.printMetadata("type", N->getRawType());
2178   Out << ")";
2179 }
2180
2181 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
2182                                   TypePrinting *TypePrinter,
2183                                   SlotTracker *Machine, const Module *Context) {
2184   Out << "!DIImportedEntity(";
2185   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2186   Printer.printTag(N);
2187   Printer.printString("name", N->getName());
2188   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2189   Printer.printMetadata("entity", N->getRawEntity());
2190   Printer.printMetadata("file", N->getRawFile());
2191   Printer.printInt("line", N->getLine());
2192   Out << ")";
2193 }
2194
2195 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
2196                                     TypePrinting *TypePrinter,
2197                                     SlotTracker *Machine,
2198                                     const Module *Context) {
2199   if (Node->isDistinct())
2200     Out << "distinct ";
2201   else if (Node->isTemporary())
2202     Out << "<temporary!> "; // Handle broken code.
2203
2204   switch (Node->getMetadataID()) {
2205   default:
2206     llvm_unreachable("Expected uniquable MDNode");
2207 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
2208   case Metadata::CLASS##Kind:                                                  \
2209     write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context);       \
2210     break;
2211 #include "llvm/IR/Metadata.def"
2212   }
2213 }
2214
2215 // Full implementation of printing a Value as an operand with support for
2216 // TypePrinting, etc.
2217 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
2218                                    TypePrinting *TypePrinter,
2219                                    SlotTracker *Machine,
2220                                    const Module *Context) {
2221   if (V->hasName()) {
2222     PrintLLVMName(Out, V);
2223     return;
2224   }
2225
2226   const Constant *CV = dyn_cast<Constant>(V);
2227   if (CV && !isa<GlobalValue>(CV)) {
2228     assert(TypePrinter && "Constants require TypePrinting!");
2229     WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
2230     return;
2231   }
2232
2233   if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2234     Out << "asm ";
2235     if (IA->hasSideEffects())
2236       Out << "sideeffect ";
2237     if (IA->isAlignStack())
2238       Out << "alignstack ";
2239     // We don't emit the AD_ATT dialect as it's the assumed default.
2240     if (IA->getDialect() == InlineAsm::AD_Intel)
2241       Out << "inteldialect ";
2242     Out << '"';
2243     printEscapedString(IA->getAsmString(), Out);
2244     Out << "\", \"";
2245     printEscapedString(IA->getConstraintString(), Out);
2246     Out << '"';
2247     return;
2248   }
2249
2250   if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2251     WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
2252                            Context, /* FromValue */ true);
2253     return;
2254   }
2255
2256   char Prefix = '%';
2257   int Slot;
2258   // If we have a SlotTracker, use it.
2259   if (Machine) {
2260     if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2261       Slot = Machine->getGlobalSlot(GV);
2262       Prefix = '@';
2263     } else {
2264       Slot = Machine->getLocalSlot(V);
2265
2266       // If the local value didn't succeed, then we may be referring to a value
2267       // from a different function.  Translate it, as this can happen when using
2268       // address of blocks.
2269       if (Slot == -1)
2270         if ((Machine = createSlotTracker(V))) {
2271           Slot = Machine->getLocalSlot(V);
2272           delete Machine;
2273         }
2274     }
2275   } else if ((Machine = createSlotTracker(V))) {
2276     // Otherwise, create one to get the # and then destroy it.
2277     if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2278       Slot = Machine->getGlobalSlot(GV);
2279       Prefix = '@';
2280     } else {
2281       Slot = Machine->getLocalSlot(V);
2282     }
2283     delete Machine;
2284     Machine = nullptr;
2285   } else {
2286     Slot = -1;
2287   }
2288
2289   if (Slot != -1)
2290     Out << Prefix << Slot;
2291   else
2292     Out << "<badref>";
2293 }
2294
2295 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2296                                    TypePrinting *TypePrinter,
2297                                    SlotTracker *Machine, const Module *Context,
2298                                    bool FromValue) {
2299   // Write DIExpressions inline when used as a value. Improves readability of
2300   // debug info intrinsics.
2301   if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
2302     writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
2303     return;
2304   }
2305
2306   if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2307     std::unique_ptr<SlotTracker> MachineStorage;
2308     if (!Machine) {
2309       MachineStorage = make_unique<SlotTracker>(Context);
2310       Machine = MachineStorage.get();
2311     }
2312     int Slot = Machine->getMetadataSlot(N);
2313     if (Slot == -1) {
2314       if (const DILocation *Loc = dyn_cast<DILocation>(N)) {
2315         writeDILocation(Out, Loc, TypePrinter, Machine, Context);
2316         return;
2317       }
2318       // Give the pointer value instead of "badref", since this comes up all
2319       // the time when debugging.
2320       Out << "<" << N << ">";
2321     } else
2322       Out << '!' << Slot;
2323     return;
2324   }
2325
2326   if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2327     Out << "!\"";
2328     printEscapedString(MDS->getString(), Out);
2329     Out << '"';
2330     return;
2331   }
2332
2333   auto *V = cast<ValueAsMetadata>(MD);
2334   assert(TypePrinter && "TypePrinter required for metadata values");
2335   assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2336          "Unexpected function-local metadata outside of value argument");
2337
2338   TypePrinter->print(V->getValue()->getType(), Out);
2339   Out << ' ';
2340   WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2341 }
2342
2343 namespace {
2344
2345 class AssemblyWriter {
2346   formatted_raw_ostream &Out;
2347   const Module *TheModule = nullptr;
2348   const ModuleSummaryIndex *TheIndex = nullptr;
2349   std::unique_ptr<SlotTracker> SlotTrackerStorage;
2350   SlotTracker &Machine;
2351   TypePrinting TypePrinter;
2352   AssemblyAnnotationWriter *AnnotationWriter = nullptr;
2353   SetVector<const Comdat *> Comdats;
2354   bool IsForDebug;
2355   bool ShouldPreserveUseListOrder;
2356   UseListOrderStack UseListOrders;
2357   SmallVector<StringRef, 8> MDNames;
2358   /// Synchronization scope names registered with LLVMContext.
2359   SmallVector<StringRef, 8> SSNs;
2360   DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;
2361
2362 public:
2363   /// Construct an AssemblyWriter with an external SlotTracker
2364   AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2365                  AssemblyAnnotationWriter *AAW, bool IsForDebug,
2366                  bool ShouldPreserveUseListOrder = false);
2367
2368   AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2369                  const ModuleSummaryIndex *Index, bool IsForDebug);
2370
2371   void printMDNodeBody(const MDNode *MD);
2372   void printNamedMDNode(const NamedMDNode *NMD);
2373
2374   void printModule(const Module *M);
2375
2376   void writeOperand(const Value *Op, bool PrintType);
2377   void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2378   void writeOperandBundles(const CallBase *Call);
2379   void writeSyncScope(const LLVMContext &Context,
2380                       SyncScope::ID SSID);
2381   void writeAtomic(const LLVMContext &Context,
2382                    AtomicOrdering Ordering,
2383                    SyncScope::ID SSID);
2384   void writeAtomicCmpXchg(const LLVMContext &Context,
2385                           AtomicOrdering SuccessOrdering,
2386                           AtomicOrdering FailureOrdering,
2387                           SyncScope::ID SSID);
2388
2389   void writeAllMDNodes();
2390   void writeMDNode(unsigned Slot, const MDNode *Node);
2391   void writeAllAttributeGroups();
2392
2393   void printTypeIdentities();
2394   void printGlobal(const GlobalVariable *GV);
2395   void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
2396   void printComdat(const Comdat *C);
2397   void printFunction(const Function *F);
2398   void printArgument(const Argument *FA, AttributeSet Attrs);
2399   void printBasicBlock(const BasicBlock *BB);
2400   void printInstructionLine(const Instruction &I);
2401   void printInstruction(const Instruction &I);
2402
2403   void printUseListOrder(const UseListOrder &Order);
2404   void printUseLists(const Function *F);
2405
2406   void printModuleSummaryIndex();
2407   void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
2408   void printSummary(const GlobalValueSummary &Summary);
2409   void printAliasSummary(const AliasSummary *AS);
2410   void printGlobalVarSummary(const GlobalVarSummary *GS);
2411   void printFunctionSummary(const FunctionSummary *FS);
2412   void printTypeIdSummary(const TypeIdSummary &TIS);
2413   void printTypeTestResolution(const TypeTestResolution &TTRes);
2414   void printArgs(const std::vector<uint64_t> &Args);
2415   void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
2416   void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
2417   void printVFuncId(const FunctionSummary::VFuncId VFId);
2418   void
2419   printNonConstVCalls(const std::vector<FunctionSummary::VFuncId> VCallList,
2420                       const char *Tag);
2421   void
2422   printConstVCalls(const std::vector<FunctionSummary::ConstVCall> VCallList,
2423                    const char *Tag);
2424
2425 private:
2426   /// Print out metadata attachments.
2427   void printMetadataAttachments(
2428       const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2429       StringRef Separator);
2430
2431   // printInfoComment - Print a little comment after the instruction indicating
2432   // which slot it occupies.
2433   void printInfoComment(const Value &V);
2434
2435   // printGCRelocateComment - print comment after call to the gc.relocate
2436   // intrinsic indicating base and derived pointer names.
2437   void printGCRelocateComment(const GCRelocateInst &Relocate);
2438 };
2439
2440 } // end anonymous namespace
2441
2442 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2443                                const Module *M, AssemblyAnnotationWriter *AAW,
2444                                bool IsForDebug, bool ShouldPreserveUseListOrder)
2445     : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),
2446       IsForDebug(IsForDebug),
2447       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2448   if (!TheModule)
2449     return;
2450   for (const GlobalObject &GO : TheModule->global_objects())
2451     if (const Comdat *C = GO.getComdat())
2452       Comdats.insert(C);
2453 }
2454
2455 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2456                                const ModuleSummaryIndex *Index, bool IsForDebug)
2457     : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(/*Module=*/nullptr),
2458       IsForDebug(IsForDebug), ShouldPreserveUseListOrder(false) {}
2459
2460 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2461   if (!Operand) {
2462     Out << "<null operand!>";
2463     return;
2464   }
2465   if (PrintType) {
2466     TypePrinter.print(Operand->getType(), Out);
2467     Out << ' ';
2468   }
2469   WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2470 }
2471
2472 void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2473                                     SyncScope::ID SSID) {
2474   switch (SSID) {
2475   case SyncScope::System: {
2476     break;
2477   }
2478   default: {
2479     if (SSNs.empty())
2480       Context.getSyncScopeNames(SSNs);
2481
2482     Out << " syncscope(\"";
2483     printEscapedString(SSNs[SSID], Out);
2484     Out << "\")";
2485     break;
2486   }
2487   }
2488 }
2489
2490 void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2491                                  AtomicOrdering Ordering,
2492                                  SyncScope::ID SSID) {
2493   if (Ordering == AtomicOrdering::NotAtomic)
2494     return;
2495
2496   writeSyncScope(Context, SSID);
2497   Out << " " << toIRString(Ordering);
2498 }
2499
2500 void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
2501                                         AtomicOrdering SuccessOrdering,
2502                                         AtomicOrdering FailureOrdering,
2503                                         SyncScope::ID SSID) {
2504   assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2505          FailureOrdering != AtomicOrdering::NotAtomic);
2506
2507   writeSyncScope(Context, SSID);
2508   Out << " " << toIRString(SuccessOrdering);
2509   Out << " " << toIRString(FailureOrdering);
2510 }
2511
2512 void AssemblyWriter::writeParamOperand(const Value *Operand,
2513                                        AttributeSet Attrs) {
2514   if (!Operand) {
2515     Out << "<null operand!>";
2516     return;
2517   }
2518
2519   // Print the type
2520   TypePrinter.print(Operand->getType(), Out);
2521   // Print parameter attributes list
2522   if (Attrs.hasAttributes())
2523     Out << ' ' << Attrs.getAsString();
2524   Out << ' ';
2525   // Print the operand
2526   WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2527 }
2528
2529 void AssemblyWriter::writeOperandBundles(const CallBase *Call) {
2530   if (!Call->hasOperandBundles())
2531     return;
2532
2533   Out << " [ ";
2534
2535   bool FirstBundle = true;
2536   for (unsigned i = 0, e = Call->getNumOperandBundles(); i != e; ++i) {
2537     OperandBundleUse BU = Call->getOperandBundleAt(i);
2538
2539     if (!FirstBundle)
2540       Out << ", ";
2541     FirstBundle = false;
2542
2543     Out << '"';
2544     printEscapedString(BU.getTagName(), Out);
2545     Out << '"';
2546
2547     Out << '(';
2548
2549     bool FirstInput = true;
2550     for (const auto &Input : BU.Inputs) {
2551       if (!FirstInput)
2552         Out << ", ";
2553       FirstInput = false;
2554
2555       TypePrinter.print(Input->getType(), Out);
2556       Out << " ";
2557       WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
2558     }
2559
2560     Out << ')';
2561   }
2562
2563   Out << " ]";
2564 }
2565
2566 void AssemblyWriter::printModule(const Module *M) {
2567   Machine.initializeIfNeeded();
2568
2569   if (ShouldPreserveUseListOrder)
2570     UseListOrders = predictUseListOrder(M);
2571
2572   if (!M->getModuleIdentifier().empty() &&
2573       // Don't print the ID if it will start a new line (which would
2574       // require a comment char before it).
2575       M->getModuleIdentifier().find('\n') == std::string::npos)
2576     Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
2577
2578   if (!M->getSourceFileName().empty()) {
2579     Out << "source_filename = \"";
2580     printEscapedString(M->getSourceFileName(), Out);
2581     Out << "\"\n";
2582   }
2583
2584   const std::string &DL = M->getDataLayoutStr();
2585   if (!DL.empty())
2586     Out << "target datalayout = \"" << DL << "\"\n";
2587   if (!M->getTargetTriple().empty())
2588     Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
2589
2590   if (!M->getModuleInlineAsm().empty()) {
2591     Out << '\n';
2592
2593     // Split the string into lines, to make it easier to read the .ll file.
2594     StringRef Asm = M->getModuleInlineAsm();
2595     do {
2596       StringRef Front;
2597       std::tie(Front, Asm) = Asm.split('\n');
2598
2599       // We found a newline, print the portion of the asm string from the
2600       // last newline up to this newline.
2601       Out << "module asm \"";
2602       printEscapedString(Front, Out);
2603       Out << "\"\n";
2604     } while (!Asm.empty());
2605   }
2606
2607   printTypeIdentities();
2608
2609   // Output all comdats.
2610   if (!Comdats.empty())
2611     Out << '\n';
2612   for (const Comdat *C : Comdats) {
2613     printComdat(C);
2614     if (C != Comdats.back())
2615       Out << '\n';
2616   }
2617
2618   // Output all globals.
2619   if (!M->global_empty()) Out << '\n';
2620   for (const GlobalVariable &GV : M->globals()) {
2621     printGlobal(&GV); Out << '\n';
2622   }
2623
2624   // Output all aliases.
2625   if (!M->alias_empty()) Out << "\n";
2626   for (const GlobalAlias &GA : M->aliases())
2627     printIndirectSymbol(&GA);
2628
2629   // Output all ifuncs.
2630   if (!M->ifunc_empty()) Out << "\n";
2631   for (const GlobalIFunc &GI : M->ifuncs())
2632     printIndirectSymbol(&GI);
2633
2634   // Output global use-lists.
2635   printUseLists(nullptr);
2636
2637   // Output all of the functions.
2638   for (const Function &F : *M)
2639     printFunction(&F);
2640   assert(UseListOrders.empty() && "All use-lists should have been consumed");
2641
2642   // Output all attribute groups.
2643   if (!Machine.as_empty()) {
2644     Out << '\n';
2645     writeAllAttributeGroups();
2646   }
2647
2648   // Output named metadata.
2649   if (!M->named_metadata_empty()) Out << '\n';
2650
2651   for (const NamedMDNode &Node : M->named_metadata())
2652     printNamedMDNode(&Node);
2653
2654   // Output metadata.
2655   if (!Machine.mdn_empty()) {
2656     Out << '\n';
2657     writeAllMDNodes();
2658   }
2659 }
2660
2661 void AssemblyWriter::printModuleSummaryIndex() {
2662   assert(TheIndex);
2663   Machine.initializeIndexIfNeeded();
2664
2665   Out << "\n";
2666
2667   // Print module path entries. To print in order, add paths to a vector
2668   // indexed by module slot.
2669   std::vector<std::pair<std::string, ModuleHash>> moduleVec;
2670   std::string RegularLTOModuleName = "[Regular LTO]";
2671   moduleVec.resize(TheIndex->modulePaths().size());
2672   for (auto &ModPath : TheIndex->modulePaths())
2673     moduleVec[Machine.getModulePathSlot(ModPath.first())] = std::make_pair(
2674         // A module id of -1 is a special entry for a regular LTO module created
2675         // during the thin link.
2676         ModPath.second.first == -1u ? RegularLTOModuleName
2677                                     : (std::string)ModPath.first(),
2678         ModPath.second.second);
2679
2680   unsigned i = 0;
2681   for (auto &ModPair : moduleVec) {
2682     Out << "^" << i++ << " = module: (";
2683     Out << "path: \"";
2684     printEscapedString(ModPair.first, Out);
2685     Out << "\", hash: (";
2686     FieldSeparator FS;
2687     for (auto Hash : ModPair.second)
2688       Out << FS << Hash;
2689     Out << "))\n";
2690   }
2691
2692   // FIXME: Change AliasSummary to hold a ValueInfo instead of summary pointer
2693   // for aliasee (then update BitcodeWriter.cpp and remove get/setAliaseeGUID).
2694   for (auto &GlobalList : *TheIndex) {
2695     auto GUID = GlobalList.first;
2696     for (auto &Summary : GlobalList.second.SummaryList)
2697       SummaryToGUIDMap[Summary.get()] = GUID;
2698   }
2699
2700   // Print the global value summary entries.
2701   for (auto &GlobalList : *TheIndex) {
2702     auto GUID = GlobalList.first;
2703     auto VI = TheIndex->getValueInfo(GlobalList);
2704     printSummaryInfo(Machine.getGUIDSlot(GUID), VI);
2705   }
2706
2707   // Print the TypeIdMap entries.
2708   for (auto TidIter = TheIndex->typeIds().begin();
2709        TidIter != TheIndex->typeIds().end(); TidIter++) {
2710     Out << "^" << Machine.getTypeIdSlot(TidIter->second.first)
2711         << " = typeid: (name: \"" << TidIter->second.first << "\"";
2712     printTypeIdSummary(TidIter->second.second);
2713     Out << ") ; guid = " << TidIter->first << "\n";
2714   }
2715 }
2716
2717 static const char *
2718 getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K) {
2719   switch (K) {
2720   case WholeProgramDevirtResolution::Indir:
2721     return "indir";
2722   case WholeProgramDevirtResolution::SingleImpl:
2723     return "singleImpl";
2724   case WholeProgramDevirtResolution::BranchFunnel:
2725     return "branchFunnel";
2726   }
2727   llvm_unreachable("invalid WholeProgramDevirtResolution kind");
2728 }
2729
2730 static const char *getWholeProgDevirtResByArgKindName(
2731     WholeProgramDevirtResolution::ByArg::Kind K) {
2732   switch (K) {
2733   case WholeProgramDevirtResolution::ByArg::Indir:
2734     return "indir";
2735   case WholeProgramDevirtResolution::ByArg::UniformRetVal:
2736     return "uniformRetVal";
2737   case WholeProgramDevirtResolution::ByArg::UniqueRetVal:
2738     return "uniqueRetVal";
2739   case WholeProgramDevirtResolution::ByArg::VirtualConstProp:
2740     return "virtualConstProp";
2741   }
2742   llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");
2743 }
2744
2745 static const char *getTTResKindName(TypeTestResolution::Kind K) {
2746   switch (K) {
2747   case TypeTestResolution::Unsat:
2748     return "unsat";
2749   case TypeTestResolution::ByteArray:
2750     return "byteArray";
2751   case TypeTestResolution::Inline:
2752     return "inline";
2753   case TypeTestResolution::Single:
2754     return "single";
2755   case TypeTestResolution::AllOnes:
2756     return "allOnes";
2757   }
2758   llvm_unreachable("invalid TypeTestResolution kind");
2759 }
2760
2761 void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {
2762   Out << "typeTestRes: (kind: " << getTTResKindName(TTRes.TheKind)
2763       << ", sizeM1BitWidth: " << TTRes.SizeM1BitWidth;
2764
2765   // The following fields are only used if the target does not support the use
2766   // of absolute symbols to store constants. Print only if non-zero.
2767   if (TTRes.AlignLog2)
2768     Out << ", alignLog2: " << TTRes.AlignLog2;
2769   if (TTRes.SizeM1)
2770     Out << ", sizeM1: " << TTRes.SizeM1;
2771   if (TTRes.BitMask)
2772     // BitMask is uint8_t which causes it to print the corresponding char.
2773     Out << ", bitMask: " << (unsigned)TTRes.BitMask;
2774   if (TTRes.InlineBits)
2775     Out << ", inlineBits: " << TTRes.InlineBits;
2776
2777   Out << ")";
2778 }
2779
2780 void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {
2781   Out << ", summary: (";
2782   printTypeTestResolution(TIS.TTRes);
2783   if (!TIS.WPDRes.empty()) {
2784     Out << ", wpdResolutions: (";
2785     FieldSeparator FS;
2786     for (auto &WPDRes : TIS.WPDRes) {
2787       Out << FS;
2788       Out << "(offset: " << WPDRes.first << ", ";
2789       printWPDRes(WPDRes.second);
2790       Out << ")";
2791     }
2792     Out << ")";
2793   }
2794   Out << ")";
2795 }
2796
2797 void AssemblyWriter::printArgs(const std::vector<uint64_t> &Args) {
2798   Out << "args: (";
2799   FieldSeparator FS;
2800   for (auto arg : Args) {
2801     Out << FS;
2802     Out << arg;
2803   }
2804   Out << ")";
2805 }
2806
2807 void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
2808   Out << "wpdRes: (kind: ";
2809   Out << getWholeProgDevirtResKindName(WPDRes.TheKind);
2810
2811   if (WPDRes.TheKind == WholeProgramDevirtResolution::SingleImpl)
2812     Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";
2813
2814   if (!WPDRes.ResByArg.empty()) {
2815     Out << ", resByArg: (";
2816     FieldSeparator FS;
2817     for (auto &ResByArg : WPDRes.ResByArg) {
2818       Out << FS;
2819       printArgs(ResByArg.first);
2820       Out << ", byArg: (kind: ";
2821       Out << getWholeProgDevirtResByArgKindName(ResByArg.second.TheKind);
2822       if (ResByArg.second.TheKind ==
2823               WholeProgramDevirtResolution::ByArg::UniformRetVal ||
2824           ResByArg.second.TheKind ==
2825               WholeProgramDevirtResolution::ByArg::UniqueRetVal)
2826         Out << ", info: " << ResByArg.second.Info;
2827
2828       // The following fields are only used if the target does not support the
2829       // use of absolute symbols to store constants. Print only if non-zero.
2830       if (ResByArg.second.Byte || ResByArg.second.Bit)
2831         Out << ", byte: " << ResByArg.second.Byte
2832             << ", bit: " << ResByArg.second.Bit;
2833
2834       Out << ")";
2835     }
2836     Out << ")";
2837   }
2838   Out << ")";
2839 }
2840
2841 static const char *getSummaryKindName(GlobalValueSummary::SummaryKind SK) {
2842   switch (SK) {
2843   case GlobalValueSummary::AliasKind:
2844     return "alias";
2845   case GlobalValueSummary::FunctionKind:
2846     return "function";
2847   case GlobalValueSummary::GlobalVarKind:
2848     return "variable";
2849   }
2850   llvm_unreachable("invalid summary kind");
2851 }
2852
2853 void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
2854   Out << ", aliasee: ";
2855   // The indexes emitted for distributed backends may not include the
2856   // aliasee summary (only if it is being imported directly). Handle
2857   // that case by just emitting "null" as the aliasee.
2858   if (AS->hasAliasee())
2859     Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
2860   else
2861     Out << "null";
2862 }
2863
2864 void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
2865   Out << ", varFlags: (readonly: " << GS->VarFlags.ReadOnly << ")";
2866 }
2867
2868 static std::string getLinkageName(GlobalValue::LinkageTypes LT) {
2869   switch (LT) {
2870   case GlobalValue::ExternalLinkage:
2871     return "external";
2872   case GlobalValue::PrivateLinkage:
2873     return "private";
2874   case GlobalValue::InternalLinkage:
2875     return "internal";
2876   case GlobalValue::LinkOnceAnyLinkage:
2877     return "linkonce";
2878   case GlobalValue::LinkOnceODRLinkage:
2879     return "linkonce_odr";
2880   case GlobalValue::WeakAnyLinkage:
2881     return "weak";
2882   case GlobalValue::WeakODRLinkage:
2883     return "weak_odr";
2884   case GlobalValue::CommonLinkage:
2885     return "common";
2886   case GlobalValue::AppendingLinkage:
2887     return "appending";
2888   case GlobalValue::ExternalWeakLinkage:
2889     return "extern_weak";
2890   case GlobalValue::AvailableExternallyLinkage:
2891     return "available_externally";
2892   }
2893   llvm_unreachable("invalid linkage");
2894 }
2895
2896 // When printing the linkage types in IR where the ExternalLinkage is
2897 // not printed, and other linkage types are expected to be printed with
2898 // a space after the name.
2899 static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT) {
2900   if (LT == GlobalValue::ExternalLinkage)
2901     return "";
2902   return getLinkageName(LT) + " ";
2903 }
2904
2905 void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
2906   Out << ", insts: " << FS->instCount();
2907
2908   FunctionSummary::FFlags FFlags = FS->fflags();
2909   if (FFlags.ReadNone | FFlags.ReadOnly | FFlags.NoRecurse |
2910       FFlags.ReturnDoesNotAlias) {
2911     Out << ", funcFlags: (";
2912     Out << "readNone: " << FFlags.ReadNone;
2913     Out << ", readOnly: " << FFlags.ReadOnly;
2914     Out << ", noRecurse: " << FFlags.NoRecurse;
2915     Out << ", returnDoesNotAlias: " << FFlags.ReturnDoesNotAlias;
2916     Out << ", noInline: " << FFlags.NoInline;
2917     Out << ")";
2918   }
2919   if (!FS->calls().empty()) {
2920     Out << ", calls: (";
2921     FieldSeparator IFS;
2922     for (auto &Call : FS->calls()) {
2923       Out << IFS;
2924       Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());
2925       if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)
2926         Out << ", hotness: " << getHotnessName(Call.second.getHotness());
2927       else if (Call.second.RelBlockFreq)
2928         Out << ", relbf: " << Call.second.RelBlockFreq;
2929       Out << ")";
2930     }
2931     Out << ")";
2932   }
2933
2934   if (const auto *TIdInfo = FS->getTypeIdInfo())
2935     printTypeIdInfo(*TIdInfo);
2936 }
2937
2938 void AssemblyWriter::printTypeIdInfo(
2939     const FunctionSummary::TypeIdInfo &TIDInfo) {
2940   Out << ", typeIdInfo: (";
2941   FieldSeparator TIDFS;
2942   if (!TIDInfo.TypeTests.empty()) {
2943     Out << TIDFS;
2944     Out << "typeTests: (";
2945     FieldSeparator FS;
2946     for (auto &GUID : TIDInfo.TypeTests) {
2947       auto TidIter = TheIndex->typeIds().equal_range(GUID);
2948       if (TidIter.first == TidIter.second) {
2949         Out << FS;
2950         Out << GUID;
2951         continue;
2952       }
2953       // Print all type id that correspond to this GUID.
2954       for (auto It = TidIter.first; It != TidIter.second; ++It) {
2955         Out << FS;
2956         auto Slot = Machine.getTypeIdSlot(It->second.first);
2957         assert(Slot != -1);
2958         Out << "^" << Slot;
2959       }
2960     }
2961     Out << ")";
2962   }
2963   if (!TIDInfo.TypeTestAssumeVCalls.empty()) {
2964     Out << TIDFS;
2965     printNonConstVCalls(TIDInfo.TypeTestAssumeVCalls, "typeTestAssumeVCalls");
2966   }
2967   if (!TIDInfo.TypeCheckedLoadVCalls.empty()) {
2968     Out << TIDFS;
2969     printNonConstVCalls(TIDInfo.TypeCheckedLoadVCalls, "typeCheckedLoadVCalls");
2970   }
2971   if (!TIDInfo.TypeTestAssumeConstVCalls.empty()) {
2972     Out << TIDFS;
2973     printConstVCalls(TIDInfo.TypeTestAssumeConstVCalls,
2974                      "typeTestAssumeConstVCalls");
2975   }
2976   if (!TIDInfo.TypeCheckedLoadConstVCalls.empty()) {
2977     Out << TIDFS;
2978     printConstVCalls(TIDInfo.TypeCheckedLoadConstVCalls,
2979                      "typeCheckedLoadConstVCalls");
2980   }
2981   Out << ")";
2982 }
2983
2984 void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {
2985   auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);
2986   if (TidIter.first == TidIter.second) {
2987     Out << "vFuncId: (";
2988     Out << "guid: " << VFId.GUID;
2989     Out << ", offset: " << VFId.Offset;
2990     Out << ")";
2991     return;
2992   }
2993   // Print all type id that correspond to this GUID.
2994   FieldSeparator FS;
2995   for (auto It = TidIter.first; It != TidIter.second; ++It) {
2996     Out << FS;
2997     Out << "vFuncId: (";
2998     auto Slot = Machine.getTypeIdSlot(It->second.first);
2999     assert(Slot != -1);
3000     Out << "^" << Slot;
3001     Out << ", offset: " << VFId.Offset;
3002     Out << ")";
3003   }
3004 }
3005
3006 void AssemblyWriter::printNonConstVCalls(
3007     const std::vector<FunctionSummary::VFuncId> VCallList, const char *Tag) {
3008   Out << Tag << ": (";
3009   FieldSeparator FS;
3010   for (auto &VFuncId : VCallList) {
3011     Out << FS;
3012     printVFuncId(VFuncId);
3013   }
3014   Out << ")";
3015 }
3016
3017 void AssemblyWriter::printConstVCalls(
3018     const std::vector<FunctionSummary::ConstVCall> VCallList, const char *Tag) {
3019   Out << Tag << ": (";
3020   FieldSeparator FS;
3021   for (auto &ConstVCall : VCallList) {
3022     Out << FS;
3023     Out << "(";
3024     printVFuncId(ConstVCall.VFunc);
3025     if (!ConstVCall.Args.empty()) {
3026       Out << ", ";
3027       printArgs(ConstVCall.Args);
3028     }
3029     Out << ")";
3030   }
3031   Out << ")";
3032 }
3033
3034 void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
3035   GlobalValueSummary::GVFlags GVFlags = Summary.flags();
3036   GlobalValue::LinkageTypes LT = (GlobalValue::LinkageTypes)GVFlags.Linkage;
3037   Out << getSummaryKindName(Summary.getSummaryKind()) << ": ";
3038   Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())
3039       << ", flags: (";
3040   Out << "linkage: " << getLinkageName(LT);
3041   Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
3042   Out << ", live: " << GVFlags.Live;
3043   Out << ", dsoLocal: " << GVFlags.DSOLocal;
3044   Out << ")";
3045
3046   if (Summary.getSummaryKind() == GlobalValueSummary::AliasKind)
3047     printAliasSummary(cast<AliasSummary>(&Summary));
3048   else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
3049     printFunctionSummary(cast<FunctionSummary>(&Summary));
3050   else
3051     printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));
3052
3053   auto RefList = Summary.refs();
3054   if (!RefList.empty()) {
3055     Out << ", refs: (";
3056     FieldSeparator FS;
3057     for (auto &Ref : RefList) {
3058       Out << FS;
3059       if (Ref.isReadOnly())
3060         Out << "readonly ";
3061       Out << "^" << Machine.getGUIDSlot(Ref.getGUID());
3062     }
3063     Out << ")";
3064   }
3065
3066   Out << ")";
3067 }
3068
3069 void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {
3070   Out << "^" << Slot << " = gv: (";
3071   if (!VI.name().empty())
3072     Out << "name: \"" << VI.name() << "\"";
3073   else
3074     Out << "guid: " << VI.getGUID();
3075   if (!VI.getSummaryList().empty()) {
3076     Out << ", summaries: (";
3077     FieldSeparator FS;
3078     for (auto &Summary : VI.getSummaryList()) {
3079       Out << FS;
3080       printSummary(*Summary);
3081     }
3082     Out << ")";
3083   }
3084   Out << ")";
3085   if (!VI.name().empty())
3086     Out << " ; guid = " << VI.getGUID();
3087   Out << "\n";
3088 }
3089
3090 static void printMetadataIdentifier(StringRef Name,
3091                                     formatted_raw_ostream &Out) {
3092   if (Name.empty()) {
3093     Out << "<empty name> ";
3094   } else {
3095     if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
3096         Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
3097       Out << Name[0];
3098     else
3099       Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
3100     for (unsigned i = 1, e = Name.size(); i != e; ++i) {
3101       unsigned char C = Name[i];
3102       if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
3103           C == '.' || C == '_')
3104         Out << C;
3105       else
3106         Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
3107     }
3108   }
3109 }
3110
3111 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
3112   Out << '!';
3113   printMetadataIdentifier(NMD->getName(), Out);
3114   Out << " = !{";
3115   for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3116     if (i)
3117       Out << ", ";
3118
3119     // Write DIExpressions inline.
3120     // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
3121     MDNode *Op = NMD->getOperand(i);
3122     if (auto *Expr = dyn_cast<DIExpression>(Op)) {
3123       writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
3124       continue;
3125     }
3126
3127     int Slot = Machine.getMetadataSlot(Op);
3128     if (Slot == -1)
3129       Out << "<badref>";
3130     else
3131       Out << '!' << Slot;
3132   }
3133   Out << "}\n";
3134 }
3135
3136 static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
3137                             formatted_raw_ostream &Out) {
3138   switch (Vis) {
3139   case GlobalValue::DefaultVisibility: break;
3140   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
3141   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
3142   }
3143 }
3144
3145 static void PrintDSOLocation(const GlobalValue &GV,
3146                              formatted_raw_ostream &Out) {
3147   // GVs with local linkage or non default visibility are implicitly dso_local,
3148   // so we don't print it.
3149   bool Implicit = GV.hasLocalLinkage() ||
3150                   (!GV.hasExternalWeakLinkage() && !GV.hasDefaultVisibility());
3151   if (GV.isDSOLocal() && !Implicit)
3152     Out << "dso_local ";
3153 }
3154
3155 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
3156                                  formatted_raw_ostream &Out) {
3157   switch (SCT) {
3158   case GlobalValue::DefaultStorageClass: break;
3159   case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
3160   case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
3161   }
3162 }
3163
3164 static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM,
3165                                   formatted_raw_ostream &Out) {
3166   switch (TLM) {
3167     case GlobalVariable::NotThreadLocal:
3168       break;
3169     case GlobalVariable::GeneralDynamicTLSModel:
3170       Out << "thread_local ";
3171       break;
3172     case GlobalVariable::LocalDynamicTLSModel:
3173       Out << "thread_local(localdynamic) ";
3174       break;
3175     case GlobalVariable::InitialExecTLSModel:
3176       Out << "thread_local(initialexec) ";
3177       break;
3178     case GlobalVariable::LocalExecTLSModel:
3179       Out << "thread_local(localexec) ";
3180       break;
3181   }
3182 }
3183
3184 static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) {
3185   switch (UA) {
3186   case GlobalVariable::UnnamedAddr::None:
3187     return "";
3188   case GlobalVariable::UnnamedAddr::Local:
3189     return "local_unnamed_addr";
3190   case GlobalVariable::UnnamedAddr::Global:
3191     return "unnamed_addr";
3192   }
3193   llvm_unreachable("Unknown UnnamedAddr");
3194 }
3195
3196 static void maybePrintComdat(formatted_raw_ostream &Out,
3197                              const GlobalObject &GO) {
3198   const Comdat *C = GO.getComdat();
3199   if (!C)
3200     return;
3201
3202   if (isa<GlobalVariable>(GO))
3203     Out << ',';
3204   Out << " comdat";
3205
3206   if (GO.getName() == C->getName())
3207     return;
3208
3209   Out << '(';
3210   PrintLLVMName(Out, C->getName(), ComdatPrefix);
3211   Out << ')';
3212 }
3213
3214 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
3215   if (GV->isMaterializable())
3216     Out << "; Materializable\n";
3217
3218   WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
3219   Out << " = ";
3220
3221   if (!GV->hasInitializer() && GV->hasExternalLinkage())
3222     Out << "external ";
3223
3224   Out << getLinkageNameWithSpace(GV->getLinkage());
3225   PrintDSOLocation(*GV, Out);
3226   PrintVisibility(GV->getVisibility(), Out);
3227   PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
3228   PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
3229   StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
3230   if (!UA.empty())
3231       Out << UA << ' ';
3232
3233   if (unsigned AddressSpace = GV->getType()->getAddressSpace())
3234     Out << "addrspace(" << AddressSpace << ") ";
3235   if (GV->isExternallyInitialized()) Out << "externally_initialized ";
3236   Out << (GV->isConstant() ? "constant " : "global ");
3237   TypePrinter.print(GV->getValueType(), Out);
3238
3239   if (GV->hasInitializer()) {
3240     Out << ' ';
3241     writeOperand(GV->getInitializer(), false);
3242   }
3243
3244   if (GV->hasSection()) {
3245     Out << ", section \"";
3246     printEscapedString(GV->getSection(), Out);
3247     Out << '"';
3248   }
3249   maybePrintComdat(Out, *GV);
3250   if (GV->getAlignment())
3251     Out << ", align " << GV->getAlignment();
3252
3253   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3254   GV->getAllMetadata(MDs);
3255   printMetadataAttachments(MDs, ", ");
3256
3257   auto Attrs = GV->getAttributes();
3258   if (Attrs.hasAttributes())
3259     Out << " #" << Machine.getAttributeGroupSlot(Attrs);
3260
3261   printInfoComment(*GV);
3262 }
3263
3264 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
3265   if (GIS->isMaterializable())
3266     Out << "; Materializable\n";
3267
3268   WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
3269   Out << " = ";
3270
3271   Out << getLinkageNameWithSpace(GIS->getLinkage());
3272   PrintDSOLocation(*GIS, Out);
3273   PrintVisibility(GIS->getVisibility(), Out);
3274   PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
3275   PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
3276   StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
3277   if (!UA.empty())
3278       Out << UA << ' ';
3279
3280   if (isa<GlobalAlias>(GIS))
3281     Out << "alias ";
3282   else if (isa<GlobalIFunc>(GIS))
3283     Out << "ifunc ";
3284   else
3285     llvm_unreachable("Not an alias or ifunc!");
3286
3287   TypePrinter.print(GIS->getValueType(), Out);
3288
3289   Out << ", ";
3290
3291   const Constant *IS = GIS->getIndirectSymbol();
3292
3293   if (!IS) {
3294     TypePrinter.print(GIS->getType(), Out);
3295     Out << " <<NULL ALIASEE>>";
3296   } else {
3297     writeOperand(IS, !isa<ConstantExpr>(IS));
3298   }
3299
3300   printInfoComment(*GIS);
3301   Out << '\n';
3302 }
3303
3304 void AssemblyWriter::printComdat(const Comdat *C) {
3305   C->print(Out);
3306 }
3307
3308 void AssemblyWriter::printTypeIdentities() {
3309   if (TypePrinter.empty())
3310     return;
3311
3312   Out << '\n';
3313
3314   // Emit all numbered types.
3315   auto &NumberedTypes = TypePrinter.getNumberedTypes();
3316   for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
3317     Out << '%' << I << " = type ";
3318
3319     // Make sure we print out at least one level of the type structure, so
3320     // that we do not get %2 = type %2
3321     TypePrinter.printStructBody(NumberedTypes[I], Out);
3322     Out << '\n';
3323   }
3324
3325   auto &NamedTypes = TypePrinter.getNamedTypes();
3326   for (unsigned I = 0, E = NamedTypes.size(); I != E; ++I) {
3327     PrintLLVMName(Out, NamedTypes[I]->getName(), LocalPrefix);
3328     Out << " = type ";
3329
3330     // Make sure we print out at least one level of the type structure, so
3331     // that we do not get %FILE = type %FILE
3332     TypePrinter.printStructBody(NamedTypes[I], Out);
3333     Out << '\n';
3334   }
3335 }
3336
3337 /// printFunction - Print all aspects of a function.
3338 void AssemblyWriter::printFunction(const Function *F) {
3339   // Print out the return type and name.
3340   Out << '\n';
3341
3342   if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
3343
3344   if (F->isMaterializable())
3345     Out << "; Materializable\n";
3346
3347   const AttributeList &Attrs = F->getAttributes();
3348   if (Attrs.hasAttributes(AttributeList::FunctionIndex)) {
3349     AttributeSet AS = Attrs.getFnAttributes();
3350     std::string AttrStr;
3351
3352     for (const Attribute &Attr : AS) {
3353       if (!Attr.isStringAttribute()) {
3354         if (!AttrStr.empty()) AttrStr += ' ';
3355         AttrStr += Attr.getAsString();
3356       }
3357     }
3358
3359     if (!AttrStr.empty())
3360       Out << "; Function Attrs: " << AttrStr << '\n';
3361   }
3362
3363   Machine.incorporateFunction(F);
3364
3365   if (F->isDeclaration()) {
3366     Out << "declare";
3367     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3368     F->getAllMetadata(MDs);
3369     printMetadataAttachments(MDs, " ");
3370     Out << ' ';
3371   } else
3372     Out << "define ";
3373
3374   Out << getLinkageNameWithSpace(F->getLinkage());
3375   PrintDSOLocation(*F, Out);
3376   PrintVisibility(F->getVisibility(), Out);
3377   PrintDLLStorageClass(F->getDLLStorageClass(), Out);
3378
3379   // Print the calling convention.
3380   if (F->getCallingConv() != CallingConv::C) {
3381     PrintCallingConv(F->getCallingConv(), Out);
3382     Out << " ";
3383   }
3384
3385   FunctionType *FT = F->getFunctionType();
3386   if (Attrs.hasAttributes(AttributeList::ReturnIndex))
3387     Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
3388   TypePrinter.print(F->getReturnType(), Out);
3389   Out << ' ';
3390   WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
3391   Out << '(';
3392
3393   // Loop over the arguments, printing them...
3394   if (F->isDeclaration() && !IsForDebug) {
3395     // We're only interested in the type here - don't print argument names.
3396     for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
3397       // Insert commas as we go... the first arg doesn't get a comma
3398       if (I)
3399         Out << ", ";
3400       // Output type...
3401       TypePrinter.print(FT->getParamType(I), Out);
3402
3403       AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
3404       if (ArgAttrs.hasAttributes())
3405         Out << ' ' << ArgAttrs.getAsString();
3406     }
3407   } else {
3408     // The arguments are meaningful here, print them in detail.
3409     for (const Argument &Arg : F->args()) {
3410       // Insert commas as we go... the first arg doesn't get a comma
3411       if (Arg.getArgNo() != 0)
3412         Out << ", ";
3413       printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
3414     }
3415   }
3416
3417   // Finish printing arguments...
3418   if (FT->isVarArg()) {
3419     if (FT->getNumParams()) Out << ", ";
3420     Out << "...";  // Output varargs portion of signature!
3421   }
3422   Out << ')';
3423   StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
3424   if (!UA.empty())
3425     Out << ' ' << UA;
3426   // We print the function address space if it is non-zero or if we are writing
3427   // a module with a non-zero program address space or if there is no valid
3428   // Module* so that the file can be parsed without the datalayout string.
3429   const Module *Mod = F->getParent();
3430   if (F->getAddressSpace() != 0 || !Mod ||
3431       Mod->getDataLayout().getProgramAddressSpace() != 0)
3432     Out << " addrspace(" << F->getAddressSpace() << ")";
3433   if (Attrs.hasAttributes(AttributeList::FunctionIndex))
3434     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
3435   if (F->hasSection()) {
3436     Out << " section \"";
3437     printEscapedString(F->getSection(), Out);
3438     Out << '"';
3439   }
3440   maybePrintComdat(Out, *F);
3441   if (F->getAlignment())
3442     Out << " align " << F->getAlignment();
3443   if (F->hasGC())
3444     Out << " gc \"" << F->getGC() << '"';
3445   if (F->hasPrefixData()) {
3446     Out << " prefix ";
3447     writeOperand(F->getPrefixData(), true);
3448   }
3449   if (F->hasPrologueData()) {
3450     Out << " prologue ";
3451     writeOperand(F->getPrologueData(), true);
3452   }
3453   if (F->hasPersonalityFn()) {
3454     Out << " personality ";
3455     writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
3456   }
3457
3458   if (F->isDeclaration()) {
3459     Out << '\n';
3460   } else {
3461     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3462     F->getAllMetadata(MDs);
3463     printMetadataAttachments(MDs, " ");
3464
3465     Out << " {";
3466     // Output all of the function's basic blocks.
3467     for (const BasicBlock &BB : *F)
3468       printBasicBlock(&BB);
3469
3470     // Output the function's use-lists.
3471     printUseLists(F);
3472
3473     Out << "}\n";
3474   }
3475
3476   Machine.purgeFunction();
3477 }
3478
3479 /// printArgument - This member is called for every argument that is passed into
3480 /// the function.  Simply print it out
3481 void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
3482   // Output type...
3483   TypePrinter.print(Arg->getType(), Out);
3484
3485   // Output parameter attributes list
3486   if (Attrs.hasAttributes())
3487     Out << ' ' << Attrs.getAsString();
3488
3489   // Output name, if available...
3490   if (Arg->hasName()) {
3491     Out << ' ';
3492     PrintLLVMName(Out, Arg);
3493   }
3494 }
3495
3496 /// printBasicBlock - This member is called for each basic block in a method.
3497 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
3498   bool IsEntryBlock = BB == &BB->getParent()->getEntryBlock();
3499   if (BB->hasName()) {              // Print out the label if it exists...
3500     Out << "\n";
3501     PrintLLVMName(Out, BB->getName(), LabelPrefix);
3502     Out << ':';
3503   } else if (!IsEntryBlock) {
3504     Out << "\n";
3505     int Slot = Machine.getLocalSlot(BB);
3506     if (Slot != -1)
3507       Out << Slot << ":";
3508     else
3509       Out << "<badref>:";
3510   }
3511
3512   if (!BB->getParent()) {
3513     Out.PadToColumn(50);
3514     Out << "; Error: Block without parent!";
3515   } else if (!IsEntryBlock) {
3516     // Output predecessors for the block.
3517     Out.PadToColumn(50);
3518     Out << ";";
3519     const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
3520
3521     if (PI == PE) {
3522       Out << " No predecessors!";
3523     } else {
3524       Out << " preds = ";
3525       writeOperand(*PI, false);
3526       for (++PI; PI != PE; ++PI) {
3527         Out << ", ";
3528         writeOperand(*PI, false);
3529       }
3530     }
3531   }
3532
3533   Out << "\n";
3534
3535   if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
3536
3537   // Output all of the instructions in the basic block...
3538   for (const Instruction &I : *BB) {
3539     printInstructionLine(I);
3540   }
3541
3542   if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
3543 }
3544
3545 /// printInstructionLine - Print an instruction and a newline character.
3546 void AssemblyWriter::printInstructionLine(const Instruction &I) {
3547   printInstruction(I);
3548   Out << '\n';
3549 }
3550
3551 /// printGCRelocateComment - print comment after call to the gc.relocate
3552 /// intrinsic indicating base and derived pointer names.
3553 void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
3554   Out << " ; (";
3555   writeOperand(Relocate.getBasePtr(), false);
3556   Out << ", ";
3557   writeOperand(Relocate.getDerivedPtr(), false);
3558   Out << ")";
3559 }
3560
3561 /// printInfoComment - Print a little comment after the instruction indicating
3562 /// which slot it occupies.
3563 void AssemblyWriter::printInfoComment(const Value &V) {
3564   if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
3565     printGCRelocateComment(*Relocate);
3566
3567   if (AnnotationWriter)
3568     AnnotationWriter->printInfoComment(V, Out);
3569 }
3570
3571 static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
3572                                     raw_ostream &Out) {
3573   // We print the address space of the call if it is non-zero.
3574   unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
3575   bool PrintAddrSpace = CallAddrSpace != 0;
3576   if (!PrintAddrSpace) {
3577     const Module *Mod = getModuleFromVal(I);
3578     // We also print it if it is zero but not equal to the program address space
3579     // or if we can't find a valid Module* to make it possible to parse
3580     // the resulting file even without a datalayout string.
3581     if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
3582       PrintAddrSpace = true;
3583   }
3584   if (PrintAddrSpace)
3585     Out << " addrspace(" << CallAddrSpace << ")";
3586 }
3587
3588 // This member is called for each Instruction in a function..
3589 void AssemblyWriter::printInstruction(const Instruction &I) {
3590   if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
3591
3592   // Print out indentation for an instruction.
3593   Out << "  ";
3594
3595   // Print out name if it exists...
3596   if (I.hasName()) {
3597     PrintLLVMName(Out, &I);
3598     Out << " = ";
3599   } else if (!I.getType()->isVoidTy()) {
3600     // Print out the def slot taken.
3601     int SlotNum = Machine.getLocalSlot(&I);
3602     if (SlotNum == -1)
3603       Out << "<badref> = ";
3604     else
3605       Out << '%' << SlotNum << " = ";
3606   }
3607
3608   if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3609     if (CI->isMustTailCall())
3610       Out << "musttail ";
3611     else if (CI->isTailCall())
3612       Out << "tail ";
3613     else if (CI->isNoTailCall())
3614       Out << "notail ";
3615   }
3616
3617   // Print out the opcode...
3618   Out << I.getOpcodeName();
3619
3620   // If this is an atomic load or store, print out the atomic marker.
3621   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isAtomic()) ||
3622       (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
3623     Out << " atomic";
3624
3625   if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
3626     Out << " weak";
3627
3628   // If this is a volatile operation, print out the volatile marker.
3629   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
3630       (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
3631       (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
3632       (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
3633     Out << " volatile";
3634
3635   // Print out optimization information.
3636   WriteOptimizationInfo(Out, &I);
3637
3638   // Print out the compare instruction predicates
3639   if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
3640     Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
3641
3642   // Print out the atomicrmw operation
3643   if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
3644     Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());
3645
3646   // Print out the type of the operands...
3647   const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
3648
3649   // Special case conditional branches to swizzle the condition out to the front
3650   if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
3651     const BranchInst &BI(cast<BranchInst>(I));
3652     Out << ' ';
3653     writeOperand(BI.getCondition(), true);
3654     Out << ", ";
3655     writeOperand(BI.getSuccessor(0), true);
3656     Out << ", ";
3657     writeOperand(BI.getSuccessor(1), true);
3658
3659   } else if (isa<SwitchInst>(I)) {
3660     const SwitchInst& SI(cast<SwitchInst>(I));
3661     // Special case switch instruction to get formatting nice and correct.
3662     Out << ' ';
3663     writeOperand(SI.getCondition(), true);
3664     Out << ", ";
3665     writeOperand(SI.getDefaultDest(), true);
3666     Out << " [";
3667     for (auto Case : SI.cases()) {
3668       Out << "\n    ";
3669       writeOperand(Case.getCaseValue(), true);
3670       Out << ", ";
3671       writeOperand(Case.getCaseSuccessor(), true);
3672     }
3673     Out << "\n  ]";
3674   } else if (isa<IndirectBrInst>(I)) {
3675     // Special case indirectbr instruction to get formatting nice and correct.
3676     Out << ' ';
3677     writeOperand(Operand, true);
3678     Out << ", [";
3679
3680     for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
3681       if (i != 1)
3682         Out << ", ";
3683       writeOperand(I.getOperand(i), true);
3684     }
3685     Out << ']';
3686   } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
3687     Out << ' ';
3688     TypePrinter.print(I.getType(), Out);
3689     Out << ' ';
3690
3691     for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
3692       if (op) Out << ", ";
3693       Out << "[ ";
3694       writeOperand(PN->getIncomingValue(op), false); Out << ", ";
3695       writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
3696     }
3697   } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
3698     Out << ' ';
3699     writeOperand(I.getOperand(0), true);
3700     for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
3701       Out << ", " << *i;
3702   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
3703     Out << ' ';
3704     writeOperand(I.getOperand(0), true); Out << ", ";
3705     writeOperand(I.getOperand(1), true);
3706     for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
3707       Out << ", " << *i;
3708   } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
3709     Out << ' ';
3710     TypePrinter.print(I.getType(), Out);
3711     if (LPI->isCleanup() || LPI->getNumClauses() != 0)
3712       Out << '\n';
3713
3714     if (LPI->isCleanup())
3715       Out << "          cleanup";
3716
3717     for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
3718       if (i != 0 || LPI->isCleanup()) Out << "\n";
3719       if (LPI->isCatch(i))
3720         Out << "          catch ";
3721       else
3722         Out << "          filter ";
3723
3724       writeOperand(LPI->getClause(i), true);
3725     }
3726   } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
3727     Out << " within ";
3728     writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
3729     Out << " [";
3730     unsigned Op = 0;
3731     for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
3732       if (Op > 0)
3733         Out << ", ";
3734       writeOperand(PadBB, /*PrintType=*/true);
3735       ++Op;
3736     }
3737     Out << "] unwind ";
3738     if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
3739       writeOperand(UnwindDest, /*PrintType=*/true);
3740     else
3741       Out << "to caller";
3742   } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
3743     Out << " within ";
3744     writeOperand(FPI->getParentPad(), /*PrintType=*/false);
3745     Out << " [";
3746     for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
3747          ++Op) {
3748       if (Op > 0)
3749         Out << ", ";
3750       writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
3751     }
3752     Out << ']';
3753   } else if (isa<ReturnInst>(I) && !Operand) {
3754     Out << " void";
3755   } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
3756     Out << " from ";
3757     writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3758
3759     Out << " to ";
3760     writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3761   } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3762     Out << " from ";
3763     writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3764
3765     Out << " unwind ";
3766     if (CRI->hasUnwindDest())
3767       writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3768     else
3769       Out << "to caller";
3770   } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3771     // Print the calling convention being used.
3772     if (CI->getCallingConv() != CallingConv::C) {
3773       Out << " ";
3774       PrintCallingConv(CI->getCallingConv(), Out);
3775     }
3776
3777     Operand = CI->getCalledValue();
3778     FunctionType *FTy = CI->getFunctionType();
3779     Type *RetTy = FTy->getReturnType();
3780     const AttributeList &PAL = CI->getAttributes();
3781
3782     if (PAL.hasAttributes(AttributeList::ReturnIndex))
3783       Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3784
3785     // Only print addrspace(N) if necessary:
3786     maybePrintCallAddrSpace(Operand, &I, Out);
3787
3788     // If possible, print out the short form of the call instruction.  We can
3789     // only do this if the first argument is a pointer to a nonvararg function,
3790     // and if the return type is not a pointer to a function.
3791     //
3792     Out << ' ';
3793     TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3794     Out << ' ';
3795     writeOperand(Operand, false);
3796     Out << '(';
3797     for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
3798       if (op > 0)
3799         Out << ", ";
3800       writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
3801     }
3802
3803     // Emit an ellipsis if this is a musttail call in a vararg function.  This
3804     // is only to aid readability, musttail calls forward varargs by default.
3805     if (CI->isMustTailCall() && CI->getParent() &&
3806         CI->getParent()->getParent() &&
3807         CI->getParent()->getParent()->isVarArg())
3808       Out << ", ...";
3809
3810     Out << ')';
3811     if (PAL.hasAttributes(AttributeList::FunctionIndex))
3812       Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3813
3814     writeOperandBundles(CI);
3815   } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3816     Operand = II->getCalledValue();
3817     FunctionType *FTy = II->getFunctionType();
3818     Type *RetTy = FTy->getReturnType();
3819     const AttributeList &PAL = II->getAttributes();
3820
3821     // Print the calling convention being used.
3822     if (II->getCallingConv() != CallingConv::C) {
3823       Out << " ";
3824       PrintCallingConv(II->getCallingConv(), Out);
3825     }
3826
3827     if (PAL.hasAttributes(AttributeList::ReturnIndex))
3828       Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3829
3830     // Only print addrspace(N) if necessary:
3831     maybePrintCallAddrSpace(Operand, &I, Out);
3832
3833     // If possible, print out the short form of the invoke instruction. We can
3834     // only do this if the first argument is a pointer to a nonvararg function,
3835     // and if the return type is not a pointer to a function.
3836     //
3837     Out << ' ';
3838     TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3839     Out << ' ';
3840     writeOperand(Operand, false);
3841     Out << '(';
3842     for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
3843       if (op)
3844         Out << ", ";
3845       writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
3846     }
3847
3848     Out << ')';
3849     if (PAL.hasAttributes(AttributeList::FunctionIndex))
3850       Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3851
3852     writeOperandBundles(II);
3853
3854     Out << "\n          to ";
3855     writeOperand(II->getNormalDest(), true);
3856     Out << " unwind ";
3857     writeOperand(II->getUnwindDest(), true);
3858   } else if (const CallBrInst *CBI = dyn_cast<CallBrInst>(&I)) {
3859     Operand = CBI->getCalledValue();
3860     FunctionType *FTy = CBI->getFunctionType();
3861     Type *RetTy = FTy->getReturnType();
3862     const AttributeList &PAL = CBI->getAttributes();
3863
3864     // Print the calling convention being used.
3865     if (CBI->getCallingConv() != CallingConv::C) {
3866       Out << " ";
3867       PrintCallingConv(CBI->getCallingConv(), Out);
3868     }
3869
3870     if (PAL.hasAttributes(AttributeList::ReturnIndex))
3871       Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3872
3873     // If possible, print out the short form of the callbr instruction. We can
3874     // only do this if the first argument is a pointer to a nonvararg function,
3875     // and if the return type is not a pointer to a function.
3876     //
3877     Out << ' ';
3878     TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3879     Out << ' ';
3880     writeOperand(Operand, false);
3881     Out << '(';
3882     for (unsigned op = 0, Eop = CBI->getNumArgOperands(); op < Eop; ++op) {
3883       if (op)
3884         Out << ", ";
3885       writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttributes(op));
3886     }
3887
3888     Out << ')';
3889     if (PAL.hasAttributes(AttributeList::FunctionIndex))
3890       Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3891
3892     writeOperandBundles(CBI);
3893
3894     Out << "\n          to ";
3895     writeOperand(CBI->getDefaultDest(), true);
3896     Out << " [";
3897     for (unsigned i = 0, e = CBI->getNumIndirectDests(); i != e; ++i) {
3898       if (i != 0)
3899         Out << ", ";
3900       writeOperand(CBI->getIndirectDest(i), true);
3901     }
3902     Out << ']';
3903   } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3904     Out << ' ';
3905     if (AI->isUsedWithInAlloca())
3906       Out << "inalloca ";
3907     if (AI->isSwiftError())
3908       Out << "swifterror ";
3909     TypePrinter.print(AI->getAllocatedType(), Out);
3910
3911     // Explicitly write the array size if the code is broken, if it's an array
3912     // allocation, or if the type is not canonical for scalar allocations.  The
3913     // latter case prevents the type from mutating when round-tripping through
3914     // assembly.
3915     if (!AI->getArraySize() || AI->isArrayAllocation() ||
3916         !AI->getArraySize()->getType()->isIntegerTy(32)) {
3917       Out << ", ";
3918       writeOperand(AI->getArraySize(), true);
3919     }
3920     if (AI->getAlignment()) {
3921       Out << ", align " << AI->getAlignment();
3922     }
3923
3924     unsigned AddrSpace = AI->getType()->getAddressSpace();
3925     if (AddrSpace != 0) {
3926       Out << ", addrspace(" << AddrSpace << ')';
3927     }
3928   } else if (isa<CastInst>(I)) {
3929     if (Operand) {
3930       Out << ' ';
3931       writeOperand(Operand, true);   // Work with broken code
3932     }
3933     Out << " to ";
3934     TypePrinter.print(I.getType(), Out);
3935   } else if (isa<VAArgInst>(I)) {
3936     if (Operand) {
3937       Out << ' ';
3938       writeOperand(Operand, true);   // Work with broken code
3939     }
3940     Out << ", ";
3941     TypePrinter.print(I.getType(), Out);
3942   } else if (Operand) {   // Print the normal way.
3943     if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
3944       Out << ' ';
3945       TypePrinter.print(GEP->getSourceElementType(), Out);
3946       Out << ',';
3947     } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
3948       Out << ' ';
3949       TypePrinter.print(LI->getType(), Out);
3950       Out << ',';
3951     }
3952
3953     // PrintAllTypes - Instructions who have operands of all the same type
3954     // omit the type from all but the first operand.  If the instruction has
3955     // different type operands (for example br), then they are all printed.
3956     bool PrintAllTypes = false;
3957     Type *TheType = Operand->getType();
3958
3959     // Select, Store and ShuffleVector always print all types.
3960     if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3961         || isa<ReturnInst>(I)) {
3962       PrintAllTypes = true;
3963     } else {
3964       for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
3965         Operand = I.getOperand(i);
3966         // note that Operand shouldn't be null, but the test helps make dump()
3967         // more tolerant of malformed IR
3968         if (Operand && Operand->getType() != TheType) {
3969           PrintAllTypes = true;    // We have differing types!  Print them all!
3970           break;
3971         }
3972       }
3973     }
3974
3975     if (!PrintAllTypes) {
3976       Out << ' ';
3977       TypePrinter.print(TheType, Out);
3978     }
3979
3980     Out << ' ';
3981     for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
3982       if (i) Out << ", ";
3983       writeOperand(I.getOperand(i), PrintAllTypes);
3984     }
3985   }
3986
3987   // Print atomic ordering/alignment for memory operations
3988   if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3989     if (LI->isAtomic())
3990       writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
3991     if (LI->getAlignment())
3992       Out << ", align " << LI->getAlignment();
3993   } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
3994     if (SI->isAtomic())
3995       writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
3996     if (SI->getAlignment())
3997       Out << ", align " << SI->getAlignment();
3998   } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
3999     writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
4000                        CXI->getFailureOrdering(), CXI->getSyncScopeID());
4001   } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
4002     writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
4003                 RMWI->getSyncScopeID());
4004   } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
4005     writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
4006   }
4007
4008   // Print Metadata info.
4009   SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
4010   I.getAllMetadata(InstMD);
4011   printMetadataAttachments(InstMD, ", ");
4012
4013   // Print a nice comment.
4014   printInfoComment(I);
4015 }
4016
4017 void AssemblyWriter::printMetadataAttachments(
4018     const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
4019     StringRef Separator) {
4020   if (MDs.empty())
4021     return;
4022
4023   if (MDNames.empty())
4024     MDs[0].second->getContext().getMDKindNames(MDNames);
4025
4026   for (const auto &I : MDs) {
4027     unsigned Kind = I.first;
4028     Out << Separator;
4029     if (Kind < MDNames.size()) {
4030       Out << "!";
4031       printMetadataIdentifier(MDNames[Kind], Out);
4032     } else
4033       Out << "!<unknown kind #" << Kind << ">";
4034     Out << ' ';
4035     WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
4036   }
4037 }
4038
4039 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
4040   Out << '!' << Slot << " = ";
4041   printMDNodeBody(Node);
4042   Out << "\n";
4043 }
4044
4045 void AssemblyWriter::writeAllMDNodes() {
4046   SmallVector<const MDNode *, 16> Nodes;
4047   Nodes.resize(Machine.mdn_size());
4048   for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
4049        I != E; ++I)
4050     Nodes[I->second] = cast<MDNode>(I->first);
4051
4052   for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
4053     writeMDNode(i, Nodes[i]);
4054   }
4055 }
4056
4057 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
4058   WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
4059 }
4060
4061 void AssemblyWriter::writeAllAttributeGroups() {
4062   std::vector<std::pair<AttributeSet, unsigned>> asVec;
4063   asVec.resize(Machine.as_size());
4064
4065   for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
4066        I != E; ++I)
4067     asVec[I->second] = *I;
4068
4069   for (const auto &I : asVec)
4070     Out << "attributes #" << I.second << " = { "
4071         << I.first.getAsString(true) << " }\n";
4072 }
4073
4074 void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
4075   bool IsInFunction = Machine.getFunction();
4076   if (IsInFunction)
4077     Out << "  ";
4078
4079   Out << "uselistorder";
4080   if (const BasicBlock *BB =
4081           IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
4082     Out << "_bb ";
4083     writeOperand(BB->getParent(), false);
4084     Out << ", ";
4085     writeOperand(BB, false);
4086   } else {
4087     Out << " ";
4088     writeOperand(Order.V, true);
4089   }
4090   Out << ", { ";
4091
4092   assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
4093   Out << Order.Shuffle[0];
4094   for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
4095     Out << ", " << Order.Shuffle[I];
4096   Out << " }\n";
4097 }
4098
4099 void AssemblyWriter::printUseLists(const Function *F) {
4100   auto hasMore =
4101       [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
4102   if (!hasMore())
4103     // Nothing to do.
4104     return;
4105
4106   Out << "\n; uselistorder directives\n";
4107   while (hasMore()) {
4108     printUseListOrder(UseListOrders.back());
4109     UseListOrders.pop_back();
4110   }
4111 }
4112
4113 //===----------------------------------------------------------------------===//
4114 //                       External Interface declarations
4115 //===----------------------------------------------------------------------===//
4116
4117 void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
4118                      bool ShouldPreserveUseListOrder,
4119                      bool IsForDebug) const {
4120   SlotTracker SlotTable(this->getParent());
4121   formatted_raw_ostream OS(ROS);
4122   AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
4123                    IsForDebug,
4124                    ShouldPreserveUseListOrder);
4125   W.printFunction(this);
4126 }
4127
4128 void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
4129                    bool ShouldPreserveUseListOrder, bool IsForDebug) const {
4130   SlotTracker SlotTable(this);
4131   formatted_raw_ostream OS(ROS);
4132   AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
4133                    ShouldPreserveUseListOrder);
4134   W.printModule(this);
4135 }
4136
4137 void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
4138   SlotTracker SlotTable(getParent());
4139   formatted_raw_ostream OS(ROS);
4140   AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
4141   W.printNamedMDNode(this);
4142 }
4143
4144 void NamedMDNode::print(raw_ostream &ROS, ModuleSlotTracker &MST,
4145                         bool IsForDebug) const {
4146   Optional<SlotTracker> LocalST;
4147   SlotTracker *SlotTable;
4148   if (auto *ST = MST.getMachine())
4149     SlotTable = ST;
4150   else {
4151     LocalST.emplace(getParent());
4152     SlotTable = &*LocalST;
4153   }
4154
4155   formatted_raw_ostream OS(ROS);
4156   AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
4157   W.printNamedMDNode(this);
4158 }
4159
4160 void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
4161   PrintLLVMName(ROS, getName(), ComdatPrefix);
4162   ROS << " = comdat ";
4163
4164   switch (getSelectionKind()) {
4165   case Comdat::Any:
4166     ROS << "any";
4167     break;
4168   case Comdat::ExactMatch:
4169     ROS << "exactmatch";
4170     break;
4171   case Comdat::Largest:
4172     ROS << "largest";
4173     break;
4174   case Comdat::NoDuplicates:
4175     ROS << "noduplicates";
4176     break;
4177   case Comdat::SameSize:
4178     ROS << "samesize";
4179     break;
4180   }
4181
4182   ROS << '\n';
4183 }
4184
4185 void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
4186   TypePrinting TP;
4187   TP.print(const_cast<Type*>(this), OS);
4188
4189   if (NoDetails)
4190     return;
4191
4192   // If the type is a named struct type, print the body as well.
4193   if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
4194     if (!STy->isLiteral()) {
4195       OS << " = type ";
4196       TP.printStructBody(STy, OS);
4197     }
4198 }
4199
4200 static bool isReferencingMDNode(const Instruction &I) {
4201   if (const auto *CI = dyn_cast<CallInst>(&I))
4202     if (Function *F = CI->getCalledFunction())
4203       if (F->isIntrinsic())
4204         for (auto &Op : I.operands())
4205           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
4206             if (isa<MDNode>(V->getMetadata()))
4207               return true;
4208   return false;
4209 }
4210
4211 void Value::print(raw_ostream &ROS, bool IsForDebug) const {
4212   bool ShouldInitializeAllMetadata = false;
4213   if (auto *I = dyn_cast<Instruction>(this))
4214     ShouldInitializeAllMetadata = isReferencingMDNode(*I);
4215   else if (isa<Function>(this) || isa<MetadataAsValue>(this))
4216     ShouldInitializeAllMetadata = true;
4217
4218   ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
4219   print(ROS, MST, IsForDebug);
4220 }
4221
4222 void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST,
4223                   bool IsForDebug) const {
4224   formatted_raw_ostream OS(ROS);
4225   SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
4226   SlotTracker &SlotTable =
4227       MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
4228   auto incorporateFunction = [&](const Function *F) {
4229     if (F)
4230       MST.incorporateFunction(*F);
4231   };
4232
4233   if (const Instruction *I = dyn_cast<Instruction>(this)) {
4234     incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
4235     AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
4236     W.printInstruction(*I);
4237   } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
4238     incorporateFunction(BB->getParent());
4239     AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
4240     W.printBasicBlock(BB);
4241   } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
4242     AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
4243     if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
4244       W.printGlobal(V);
4245     else if (const Function *F = dyn_cast<Function>(GV))
4246       W.printFunction(F);
4247     else
4248       W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
4249   } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
4250     V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
4251   } else if (const Constant *C = dyn_cast<Constant>(this)) {
4252     TypePrinting TypePrinter;
4253     TypePrinter.print(C->getType(), OS);
4254     OS << ' ';
4255     WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
4256   } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
4257     this->printAsOperand(OS, /* PrintType */ true, MST);
4258   } else {
4259     llvm_unreachable("Unknown value to print out!");
4260   }
4261 }
4262
4263 /// Print without a type, skipping the TypePrinting object.
4264 ///
4265 /// \return \c true iff printing was successful.
4266 static bool printWithoutType(const Value &V, raw_ostream &O,
4267                              SlotTracker *Machine, const Module *M) {
4268   if (V.hasName() || isa<GlobalValue>(V) ||
4269       (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
4270     WriteAsOperandInternal(O, &V, nullptr, Machine, M);
4271     return true;
4272   }
4273   return false;
4274 }
4275
4276 static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
4277                                ModuleSlotTracker &MST) {
4278   TypePrinting TypePrinter(MST.getModule());
4279   if (PrintType) {
4280     TypePrinter.print(V.getType(), O);
4281     O << ' ';
4282   }
4283
4284   WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
4285                          MST.getModule());
4286 }
4287
4288 void Value::printAsOperand(raw_ostream &O, bool PrintType,
4289                            const Module *M) const {
4290   if (!M)
4291     M = getModuleFromVal(this);
4292
4293   if (!PrintType)
4294     if (printWithoutType(*this, O, nullptr, M))
4295       return;
4296
4297   SlotTracker Machine(
4298       M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
4299   ModuleSlotTracker MST(Machine, M);
4300   printAsOperandImpl(*this, O, PrintType, MST);
4301 }
4302
4303 void Value::printAsOperand(raw_ostream &O, bool PrintType,
4304                            ModuleSlotTracker &MST) const {
4305   if (!PrintType)
4306     if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
4307       return;
4308
4309   printAsOperandImpl(*this, O, PrintType, MST);
4310 }
4311
4312 static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
4313                               ModuleSlotTracker &MST, const Module *M,
4314                               bool OnlyAsOperand) {
4315   formatted_raw_ostream OS(ROS);
4316
4317   TypePrinting TypePrinter(M);
4318
4319   WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
4320                          /* FromValue */ true);
4321
4322   auto *N = dyn_cast<MDNode>(&MD);
4323   if (OnlyAsOperand || !N || isa<DIExpression>(MD))
4324     return;
4325
4326   OS << " = ";
4327   WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
4328 }
4329
4330 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
4331   ModuleSlotTracker MST(M, isa<MDNode>(this));
4332   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4333 }
4334
4335 void Metadata::printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
4336                               const Module *M) const {
4337   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4338 }
4339
4340 void Metadata::print(raw_ostream &OS, const Module *M,
4341                      bool /*IsForDebug*/) const {
4342   ModuleSlotTracker MST(M, isa<MDNode>(this));
4343   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
4344 }
4345
4346 void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
4347                      const Module *M, bool /*IsForDebug*/) const {
4348   printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
4349 }
4350
4351 void ModuleSummaryIndex::print(raw_ostream &ROS, bool IsForDebug) const {
4352   SlotTracker SlotTable(this);
4353   formatted_raw_ostream OS(ROS);
4354   AssemblyWriter W(OS, SlotTable, this, IsForDebug);
4355   W.printModuleSummaryIndex();
4356 }
4357
4358 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
4359 // Value::dump - allow easy printing of Values from the debugger.
4360 LLVM_DUMP_METHOD
4361 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
4362
4363 // Type::dump - allow easy printing of Types from the debugger.
4364 LLVM_DUMP_METHOD
4365 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
4366
4367 // Module::dump() - Allow printing of Modules from the debugger.
4368 LLVM_DUMP_METHOD
4369 void Module::dump() const {
4370   print(dbgs(), nullptr,
4371         /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
4372 }
4373
4374 // Allow printing of Comdats from the debugger.
4375 LLVM_DUMP_METHOD
4376 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4377
4378 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
4379 LLVM_DUMP_METHOD
4380 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4381
4382 LLVM_DUMP_METHOD
4383 void Metadata::dump() const { dump(nullptr); }
4384
4385 LLVM_DUMP_METHOD
4386 void Metadata::dump(const Module *M) const {
4387   print(dbgs(), M, /*IsForDebug=*/true);
4388   dbgs() << '\n';
4389 }
4390
4391 // Allow printing of ModuleSummaryIndex from the debugger.
4392 LLVM_DUMP_METHOD
4393 void ModuleSummaryIndex::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4394 #endif