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