/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/IR/AsmWriter.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/IR/AsmWriter.cpp
Warning:	line 1945, column 33 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name AsmWriter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/IR/AsmWriter.cpp

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/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//===----------------------------------------------------------------------===//

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>

88using namespace llvm;

90// Make virtual table appear in this compilation unit.
91AssemblyAnnotationWriter::~AssemblyAnnotationWriter() = default;

93//===----------------------------------------------------------------------===//
94// Helper Functions
95//===----------------------------------------------------------------------===//

97using OrderMap = MapVector<const Value *, unsigned>;

99using UseListOrderMap =
  DenseMap<const Function *, MapVector<const Value *, std::vector<unsigned>>>;

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.
104static const Value *skipMetadataWrapper(const Value *V) {
if (const auto *MAV = dyn_cast<MetadataAsValue>(V))
  if (const auto *VAM = dyn_cast<ValueAsMetadata>(MAV->getMetadata()))
    return VAM->getValue();
return V;
109}

111static void orderValue(const Value *V, OrderMap &OM) {
if (OM.lookup(V))
  return;

if (const Constant *C = dyn_cast<Constant>(V))
  if (C->getNumOperands() && !isa<GlobalValue>(C))
    for (const Value *Op : C->operands())
      if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
        orderValue(Op, OM);

// Note: we cannot cache this lookup above, since inserting into the map
// changes the map's size, and thus affects the other IDs.
unsigned ID = OM.size() + 1;
OM[V] = ID;
125}

127static OrderMap orderModule(const Module *M) {
OrderMap OM;

for (const GlobalVariable &G : M->globals()) {
  if (G.hasInitializer())
    if (!isa<GlobalValue>(G.getInitializer()))
      orderValue(G.getInitializer(), OM);
  orderValue(&G, OM);
}
for (const GlobalAlias &A : M->aliases()) {
  if (!isa<GlobalValue>(A.getAliasee()))
    orderValue(A.getAliasee(), OM);
  orderValue(&A, OM);
}
for (const GlobalIFunc &I : M->ifuncs()) {
  if (!isa<GlobalValue>(I.getResolver()))
    orderValue(I.getResolver(), OM);
  orderValue(&I, OM);
}
for (const Function &F : *M) {
  for (const Use &U : F.operands())
    if (!isa<GlobalValue>(U.get()))
      orderValue(U.get(), OM);

  orderValue(&F, OM);

  if (F.isDeclaration())
    continue;

  for (const Argument &A : F.args())
    orderValue(&A, OM);
  for (const BasicBlock &BB : F) {
    orderValue(&BB, OM);
    for (const Instruction &I : BB) {
      for (const Value *Op : I.operands()) {
        Op = skipMetadataWrapper(Op);
        if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
            isa<InlineAsm>(*Op))
          orderValue(Op, OM);
      }
      orderValue(&I, OM);
    }
  }
}
return OM;
172}

174static std::vector<unsigned>
175predictValueUseListOrder(const Value *V, unsigned ID, const OrderMap &OM) {
// Predict use-list order for this one.
using Entry = std::pair<const Use *, unsigned>;
SmallVector<Entry, 64> List;
for (const Use &U : V->uses())
  // Check if this user will be serialized.
  if (OM.lookup(U.getUser()))
    List.push_back(std::make_pair(&U, List.size()));

if (List.size() < 2)
  // We may have lost some users.
  return {};

// When referencing a value before its declaration, a temporary value is
// created, which will later be RAUWed with the actual value. This reverses
// the use list. This happens for all values apart from basic blocks.
bool GetsReversed = !isa<BasicBlock>(V);
if (auto *BA = dyn_cast<BlockAddress>(V))
  ID = OM.lookup(BA->getBasicBlock());
llvm::sort(List, [&](const Entry &L, const Entry &R) {
  const Use *LU = L.first;
  const Use *RU = R.first;
  if (LU == RU)
    return false;

  auto LID = OM.lookup(LU->getUser());
  auto RID = OM.lookup(RU->getUser());

  // If ID is 4, then expect: 7 6 5 1 2 3.
  if (LID < RID) {
    if (GetsReversed)
      if (RID <= ID)
        return true;
    return false;
  }
  if (RID < LID) {
    if (GetsReversed)
      if (LID <= ID)
        return false;
    return true;
  }

  // LID and RID are equal, so we have different operands of the same user.
  // Assume operands are added in order for all instructions.
  if (GetsReversed)
    if (LID <= ID)
      return LU->getOperandNo() < RU->getOperandNo();
  return LU->getOperandNo() > RU->getOperandNo();
});

if (llvm::is_sorted(List, [](const Entry &L, const Entry &R) {
      return L.second < R.second;
    }))
  // Order is already correct.
  return {};

// Store the shuffle.
std::vector<unsigned> Shuffle(List.size());
for (size_t I = 0, E = List.size(); I != E; ++I)
  Shuffle[I] = List[I].second;
return Shuffle;
236}

238static UseListOrderMap predictUseListOrder(const Module *M) {
OrderMap OM = orderModule(M);
UseListOrderMap ULOM;
for (const auto &Pair : OM) {
  const Value *V = Pair.first;
  if (V->use_empty() || std::next(V->use_begin()) == V->use_end())
    continue;

  std::vector<unsigned> Shuffle =
      predictValueUseListOrder(V, Pair.second, OM);
  if (Shuffle.empty())
    continue;

  const Function *F = nullptr;
  if (auto *I = dyn_cast<Instruction>(V))
    F = I->getFunction();
  if (auto *A = dyn_cast<Argument>(V))
    F = A->getParent();
  if (auto *BB = dyn_cast<BasicBlock>(V))
    F = BB->getParent();
  ULOM[F][V] = std::move(Shuffle);
}
return ULOM;
261}

263static const Module *getModuleFromVal(const Value *V) {
if (const Argument *MA = dyn_cast<Argument>(V))
  return MA->getParent() ? MA->getParent()->getParent() : nullptr;

if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
  return BB->getParent() ? BB->getParent()->getParent() : nullptr;

if (const Instruction *I = dyn_cast<Instruction>(V)) {
  const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
  return M ? M->getParent() : nullptr;
}

if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
  return GV->getParent();

if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
  for (const User *U : MAV->users())
    if (isa<Instruction>(U))
      if (const Module *M = getModuleFromVal(U))
        return M;
  return nullptr;
}

return nullptr;
287}

289static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
switch (cc) {
default:                         Out << "cc" << cc; break;
case CallingConv::Fast:          Out << "fastcc"; break;
case CallingConv::Cold:          Out << "coldcc"; break;
case CallingConv::WebKit_JS:     Out << "webkit_jscc"; break;
case CallingConv::AnyReg:        Out << "anyregcc"; break;
case CallingConv::PreserveMost:  Out << "preserve_mostcc"; break;
case CallingConv::PreserveAll:   Out << "preserve_allcc"; break;
case CallingConv::CXX_FAST_TLS:  Out << "cxx_fast_tlscc"; break;
case CallingConv::GHC:           Out << "ghccc"; break;
case CallingConv::Tail:          Out << "tailcc"; break;
case CallingConv::CFGuard_Check: Out << "cfguard_checkcc"; break;
case CallingConv::X86_StdCall:   Out << "x86_stdcallcc"; break;
case CallingConv::X86_FastCall:  Out << "x86_fastcallcc"; break;
case CallingConv::X86_ThisCall:  Out << "x86_thiscallcc"; break;
case CallingConv::X86_RegCall:   Out << "x86_regcallcc"; break;
case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
case CallingConv::Intel_OCL_BI:  Out << "intel_ocl_bicc"; break;
case CallingConv::ARM_APCS:      Out << "arm_apcscc"; break;
case CallingConv::ARM_AAPCS:     Out << "arm_aapcscc"; break;
case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
case CallingConv::AArch64_VectorCall: Out << "aarch64_vector_pcs"; break;
case CallingConv::AArch64_SVE_VectorCall:
  Out << "aarch64_sve_vector_pcs";
  break;
case CallingConv::MSP430_INTR:   Out << "msp430_intrcc"; break;
case CallingConv::AVR_INTR:      Out << "avr_intrcc "; break;
case CallingConv::AVR_SIGNAL:    Out << "avr_signalcc "; break;
case CallingConv::PTX_Kernel:    Out << "ptx_kernel"; break;
case CallingConv::PTX_Device:    Out << "ptx_device"; break;
case CallingConv::X86_64_SysV:   Out << "x86_64_sysvcc"; break;
case CallingConv::Win64:         Out << "win64cc"; break;
case CallingConv::SPIR_FUNC:     Out << "spir_func"; break;
case CallingConv::SPIR_KERNEL:   Out << "spir_kernel"; break;
case CallingConv::Swift:         Out << "swiftcc"; break;
case CallingConv::SwiftTail:     Out << "swifttailcc"; break;
case CallingConv::X86_INTR:      Out << "x86_intrcc"; break;
case CallingConv::HHVM:          Out << "hhvmcc"; break;
case CallingConv::HHVM_C:        Out << "hhvm_ccc"; break;
case CallingConv::AMDGPU_VS:     Out << "amdgpu_vs"; break;
case CallingConv::AMDGPU_LS:     Out << "amdgpu_ls"; break;
case CallingConv::AMDGPU_HS:     Out << "amdgpu_hs"; break;
case CallingConv::AMDGPU_ES:     Out << "amdgpu_es"; break;
case CallingConv::AMDGPU_GS:     Out << "amdgpu_gs"; break;
case CallingConv::AMDGPU_PS:     Out << "amdgpu_ps"; break;
case CallingConv::AMDGPU_CS:     Out << "amdgpu_cs"; break;
case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
case CallingConv::AMDGPU_Gfx:    Out << "amdgpu_gfx"; break;
}
339}

341enum PrefixType {
GlobalPrefix,
ComdatPrefix,
LabelPrefix,
LocalPrefix,
NoPrefix
347};

349void llvm::printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name) {
assert(!Name.empty() && "Cannot get empty name!")((void)0);

// Scan the name to see if it needs quotes first.
bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
if (!NeedsQuotes) {
  for (unsigned i = 0, e = Name.size(); i != e; ++i) {
    // By making this unsigned, the value passed in to isalnum will always be
    // in the range 0-255.  This is important when building with MSVC because
    // its implementation will assert.  This situation can arise when dealing
    // with UTF-8 multibyte characters.
    unsigned char C = Name[i];
    if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
        C != '_') {
      NeedsQuotes = true;
      break;
    }
  }
}

// If we didn't need any quotes, just write out the name in one blast.
if (!NeedsQuotes) {
  OS << Name;
  return;
}

// Okay, we need quotes.  Output the quotes and escape any scary characters as
// needed.
OS << '"';
printEscapedString(Name, OS);
OS << '"';
380}

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.
385static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
switch (Prefix) {
case NoPrefix:
  break;
case GlobalPrefix:
  OS << '@';
  break;
case ComdatPrefix:
  OS << '$';
  break;
case LabelPrefix:
  break;
case LocalPrefix:
  OS << '%';
  break;
}
printLLVMNameWithoutPrefix(OS, Name);
402}

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.
407static void PrintLLVMName(raw_ostream &OS, const Value *V) {
PrintLLVMName(OS, V->getName(),
              isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
410}

412static void PrintShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef<int> Mask) {
Out << ", <";
if (isa<ScalableVectorType>(Ty))
  Out << "vscale x ";
Out << Mask.size() << " x i32> ";
bool FirstElt = true;
if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
  Out << "zeroinitializer";
} else if (all_of(Mask, [](int Elt) { return Elt == UndefMaskElem; })) {
  Out << "undef";
} else {
  Out << "<";
  for (int Elt : Mask) {
    if (FirstElt)
      FirstElt = false;
    else
      Out << ", ";
    Out << "i32 ";
    if (Elt == UndefMaskElem)
      Out << "undef";
    else
      Out << Elt;
  }
  Out << ">";
}
437}

439namespace {

441class TypePrinting {
442public:
TypePrinting(const Module *M = nullptr) : DeferredM(M) {}

TypePrinting(const TypePrinting &) = delete;
TypePrinting &operator=(const TypePrinting &) = delete;

/// The named types that are used by the current module.
TypeFinder &getNamedTypes();

/// The numbered types, number to type mapping.
std::vector<StructType *> &getNumberedTypes();

bool empty();

void print(Type *Ty, raw_ostream &OS);

void printStructBody(StructType *Ty, raw_ostream &OS);

460private:
void incorporateTypes();

/// A module to process lazily when needed. Set to nullptr as soon as used.
const Module *DeferredM;

TypeFinder NamedTypes;

// The numbered types, along with their value.
DenseMap<StructType *, unsigned> Type2Number;

std::vector<StructType *> NumberedTypes;
472};

474} // end anonymous namespace

476TypeFinder &TypePrinting::getNamedTypes() {
incorporateTypes();
return NamedTypes;
479}

481std::vector<StructType *> &TypePrinting::getNumberedTypes() {
incorporateTypes();

// We know all the numbers that each type is used and we know that it is a
// dense assignment. Convert the map to an index table, if it's not done
// already (judging from the sizes):
if (NumberedTypes.size() == Type2Number.size())
  return NumberedTypes;

NumberedTypes.resize(Type2Number.size());
for (const auto &P : Type2Number) {
  assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?")((void)0);
  assert(!NumberedTypes[P.second] && "Didn't get a unique numbering?")((void)0);
  NumberedTypes[P.second] = P.first;
}
return NumberedTypes;
497}

499bool TypePrinting::empty() {
incorporateTypes();
return NamedTypes.empty() && Type2Number.empty();
502}

504void TypePrinting::incorporateTypes() {
if (!DeferredM)
  return;

NamedTypes.run(*DeferredM, false);
DeferredM = nullptr;

// The list of struct types we got back includes all the struct types, split
// the unnamed ones out to a numbering and remove the anonymous structs.
unsigned NextNumber = 0;

std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
  StructType *STy = *I;

  // Ignore anonymous types.
  if (STy->isLiteral())
    continue;

  if (STy->getName().empty())
    Type2Number[STy] = NextNumber++;
  else
    *NextToUse++ = STy;
}

NamedTypes.erase(NextToUse, NamedTypes.end());
530}

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.
534void TypePrinting::print(Type *Ty, raw_ostream &OS) {
switch (Ty->getTypeID()) {
case Type::VoidTyID:      OS << "void"; return;
case Type::HalfTyID:      OS << "half"; return;
case Type::BFloatTyID:    OS << "bfloat"; return;
case Type::FloatTyID:     OS << "float"; return;
case Type::DoubleTyID:    OS << "double"; return;
case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
case Type::FP128TyID:     OS << "fp128"; return;
case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
case Type::LabelTyID:     OS << "label"; return;
case Type::MetadataTyID:  OS << "metadata"; return;
case Type::X86_MMXTyID:   OS << "x86_mmx"; return;
case Type::X86_AMXTyID:   OS << "x86_amx"; return;
case Type::TokenTyID:     OS << "token"; return;
case Type::IntegerTyID:
  OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
  return;

case Type::FunctionTyID: {
  FunctionType *FTy = cast<FunctionType>(Ty);
  print(FTy->getReturnType(), OS);
  OS << " (";
  for (FunctionType::param_iterator I = FTy->param_begin(),
       E = FTy->param_end(); I != E; ++I) {
    if (I != FTy->param_begin())
      OS << ", ";
    print(*I, OS);
  }
  if (FTy->isVarArg()) {
    if (FTy->getNumParams()) OS << ", ";
    OS << "...";
  }
  OS << ')';
  return;
}
case Type::StructTyID: {
  StructType *STy = cast<StructType>(Ty);

  if (STy->isLiteral())
    return printStructBody(STy, OS);

  if (!STy->getName().empty())
    return PrintLLVMName(OS, STy->getName(), LocalPrefix);

  incorporateTypes();
  const auto I = Type2Number.find(STy);
  if (I != Type2Number.end())
    OS << '%' << I->second;
  else  // Not enumerated, print the hex address.
    OS << "%\"type " << STy << '\"';
  return;
}
case Type::PointerTyID: {
  PointerType *PTy = cast<PointerType>(Ty);
  if (PTy->isOpaque()) {
    OS << "ptr";
    if (unsigned AddressSpace = PTy->getAddressSpace())
      OS << " addrspace(" << AddressSpace << ')';
    return;
  }
  print(PTy->getElementType(), OS);
  if (unsigned AddressSpace = PTy->getAddressSpace())
    OS << " addrspace(" << AddressSpace << ')';
  OS << '*';
  return;
}
case Type::ArrayTyID: {
  ArrayType *ATy = cast<ArrayType>(Ty);
  OS << '[' << ATy->getNumElements() << " x ";
  print(ATy->getElementType(), OS);
  OS << ']';
  return;
}
case Type::FixedVectorTyID:
case Type::ScalableVectorTyID: {
  VectorType *PTy = cast<VectorType>(Ty);
  ElementCount EC = PTy->getElementCount();
  OS << "<";
  if (EC.isScalable())
    OS << "vscale x ";
  OS << EC.getKnownMinValue() << " x ";
  print(PTy->getElementType(), OS);
  OS << '>';
  return;
}
}
llvm_unreachable("Invalid TypeID")__builtin_unreachable();
622}

624void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
if (STy->isOpaque()) {
  OS << "opaque";
  return;
}

if (STy->isPacked())
  OS << '<';

if (STy->getNumElements() == 0) {
  OS << "{}";
} else {
  StructType::element_iterator I = STy->element_begin();
  OS << "{ ";
  print(*I++, OS);
  for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
    OS << ", ";
    print(*I, OS);
  }

  OS << " }";
}
if (STy->isPacked())
  OS << '>';
648}

650AbstractSlotTrackerStorage::~AbstractSlotTrackerStorage() {}

652namespace llvm {

654//===----------------------------------------------------------------------===//
655// SlotTracker Class: Enumerate slot numbers for unnamed values
656//===----------------------------------------------------------------------===//
657/// This class provides computation of slot numbers for LLVM Assembly writing.
658///
659class SlotTracker : public AbstractSlotTrackerStorage {
660public:
/// ValueMap - A mapping of Values to slot numbers.
using ValueMap = DenseMap<const Value *, unsigned>;

664private:
/// TheModule - The module for which we are holding slot numbers.
const Module* TheModule;

/// TheFunction - The function for which we are holding slot numbers.
const Function* TheFunction = nullptr;
bool FunctionProcessed = false;
bool ShouldInitializeAllMetadata;

std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
    ProcessModuleHookFn;
std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
    ProcessFunctionHookFn;

/// The summary index for which we are holding slot numbers.
const ModuleSummaryIndex *TheIndex = nullptr;

/// mMap - The slot map for the module level data.
ValueMap mMap;
unsigned mNext = 0;

/// fMap - The slot map for the function level data.
ValueMap fMap;
unsigned fNext = 0;

/// mdnMap - Map for MDNodes.
DenseMap<const MDNode*, unsigned> mdnMap;
unsigned mdnNext = 0;

/// asMap - The slot map for attribute sets.
DenseMap<AttributeSet, unsigned> asMap;
unsigned asNext = 0;

/// ModulePathMap - The slot map for Module paths used in the summary index.
StringMap<unsigned> ModulePathMap;
unsigned ModulePathNext = 0;

/// GUIDMap - The slot map for GUIDs used in the summary index.
DenseMap<GlobalValue::GUID, unsigned> GUIDMap;
unsigned GUIDNext = 0;

/// TypeIdMap - The slot map for type ids used in the summary index.
StringMap<unsigned> TypeIdMap;
unsigned TypeIdNext = 0;

709public:
/// Construct from a module.
///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized).
explicit SlotTracker(const Module *M,
                     bool ShouldInitializeAllMetadata = false);

/// Construct from a function, starting out in incorp state.
///
/// If \c ShouldInitializeAllMetadata, initializes all metadata in all
/// functions, giving correct numbering for metadata referenced only from
/// within a function (even if no functions have been initialized).
explicit SlotTracker(const Function *F,
                     bool ShouldInitializeAllMetadata = false);

/// Construct from a module summary index.
explicit SlotTracker(const ModuleSummaryIndex *Index);

SlotTracker(const SlotTracker &) = delete;
SlotTracker &operator=(const SlotTracker &) = delete;

~SlotTracker() = default;

void setProcessHook(
    std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>);
void setProcessHook(std::function<void(AbstractSlotTrackerStorage *,
                                       const Function *, bool)>);

unsigned getNextMetadataSlot() override { return mdnNext; }

void createMetadataSlot(const MDNode *N) override;

/// Return the slot number of the specified value in it's type
/// plane.  If something is not in the SlotTracker, return -1.
int getLocalSlot(const Value *V);
int getGlobalSlot(const GlobalValue *V);
int getMetadataSlot(const MDNode *N) override;
int getAttributeGroupSlot(AttributeSet AS);
int getModulePathSlot(StringRef Path);
int getGUIDSlot(GlobalValue::GUID GUID);
int getTypeIdSlot(StringRef Id);

/// If you'd like to deal with a function instead of just a module, use
/// this method to get its data into the SlotTracker.
void incorporateFunction(const Function *F) {
  TheFunction = F;
  FunctionProcessed = false;
}

const Function *getFunction() const { return TheFunction; }

/// After calling incorporateFunction, use this method to remove the
/// most recently incorporated function from the SlotTracker. This
/// will reset the state of the machine back to just the module contents.
void purgeFunction();

/// MDNode map iterators.
using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;

mdn_iterator mdn_begin() { return mdnMap.begin(); }
mdn_iterator mdn_end() { return mdnMap.end(); }
unsigned mdn_size() const { return mdnMap.size(); }
bool mdn_empty() const { return mdnMap.empty(); }

/// AttributeSet map iterators.
using as_iterator = DenseMap<AttributeSet, unsigned>::iterator;

as_iterator as_begin()   { return asMap.begin(); }
as_iterator as_end()     { return asMap.end(); }
unsigned as_size() const { return asMap.size(); }
bool as_empty() const    { return asMap.empty(); }

/// GUID map iterators.
using guid_iterator = DenseMap<GlobalValue::GUID, unsigned>::iterator;

/// These functions do the actual initialization.
inline void initializeIfNeeded();
int initializeIndexIfNeeded();

// Implementation Details
791private:
/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
void CreateModuleSlot(const GlobalValue *V);

/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
void CreateMetadataSlot(const MDNode *N);

/// CreateFunctionSlot - Insert the specified Value* into the slot table.
void CreateFunctionSlot(const Value *V);

/// Insert the specified AttributeSet into the slot table.
void CreateAttributeSetSlot(AttributeSet AS);

inline void CreateModulePathSlot(StringRef Path);
void CreateGUIDSlot(GlobalValue::GUID GUID);
void CreateTypeIdSlot(StringRef Id);

/// Add all of the module level global variables (and their initializers)
/// and function declarations, but not the contents of those functions.
void processModule();
// Returns number of allocated slots
int processIndex();

/// Add all of the functions arguments, basic blocks, and instructions.
void processFunction();

/// Add the metadata directly attached to a GlobalObject.
void processGlobalObjectMetadata(const GlobalObject &GO);

/// Add all of the metadata from a function.
void processFunctionMetadata(const Function &F);

/// Add all of the metadata from an instruction.
void processInstructionMetadata(const Instruction &I);
825};

827} // end namespace llvm

829ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
                                   const Function *F)
  : M(M), F(F), Machine(&Machine) {}

833ModuleSlotTracker::ModuleSlotTracker(const Module *M,
                                   bool ShouldInitializeAllMetadata)
  : ShouldCreateStorage(M),
    ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}

838ModuleSlotTracker::~ModuleSlotTracker() = default;

840SlotTracker *ModuleSlotTracker::getMachine() {
if (!ShouldCreateStorage)
  return Machine;

ShouldCreateStorage = false;
MachineStorage =
    std::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
Machine = MachineStorage.get();
if (ProcessModuleHookFn)
  Machine->setProcessHook(ProcessModuleHookFn);
if (ProcessFunctionHookFn)
  Machine->setProcessHook(ProcessFunctionHookFn);
return Machine;
853}

855void ModuleSlotTracker::incorporateFunction(const Function &F) {
// Using getMachine() may lazily create the slot tracker.
if (!getMachine())
  return;

// Nothing to do if this is the right function already.
if (this->F == &F)
  return;
if (this->F)
  Machine->purgeFunction();
Machine->incorporateFunction(&F);
this->F = &F;
867}

869int ModuleSlotTracker::getLocalSlot(const Value *V) {
assert(F && "No function incorporated")((void)0);
return Machine->getLocalSlot(V);
872}

874void ModuleSlotTracker::setProcessHook(
  std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
      Fn) {
ProcessModuleHookFn = Fn;
878}

880void ModuleSlotTracker::setProcessHook(
  std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
      Fn) {
ProcessFunctionHookFn = Fn;
884}

886static SlotTracker *createSlotTracker(const Value *V) {
if (const Argument *FA = dyn_cast<Argument>(V))
  return new SlotTracker(FA->getParent());

if (const Instruction *I = dyn_cast<Instruction>(V))
  if (I->getParent())
    return new SlotTracker(I->getParent()->getParent());

if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
  return new SlotTracker(BB->getParent());

if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
  return new SlotTracker(GV->getParent());

if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
  return new SlotTracker(GA->getParent());

if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
  return new SlotTracker(GIF->getParent());

if (const Function *Func = dyn_cast<Function>(V))
  return new SlotTracker(Func);

return nullptr;
910}

912#if 0
913#define ST_DEBUG(X) dbgs() << X
914#else
915#define ST_DEBUG(X)
916#endif

918// Module level constructor. Causes the contents of the Module (sans functions)
919// to be added to the slot table.
920SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
  : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}

923// Function level constructor. Causes the contents of the Module and the one
924// function provided to be added to the slot table.
925SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
  : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
    ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}

929SlotTracker::SlotTracker(const ModuleSummaryIndex *Index)
  : TheModule(nullptr), ShouldInitializeAllMetadata(false), TheIndex(Index) {}

932inline void SlotTracker::initializeIfNeeded() {
if (TheModule) {
  processModule();
  TheModule = nullptr; ///< Prevent re-processing next time we're called.
}

if (TheFunction && !FunctionProcessed)
  processFunction();
940}

942int SlotTracker::initializeIndexIfNeeded() {
if (!TheIndex)
  return 0;
int NumSlots = processIndex();
TheIndex = nullptr; ///< Prevent re-processing next time we're called.
return NumSlots;
948}

950// Iterate through all the global variables, functions, and global
951// variable initializers and create slots for them.
952void SlotTracker::processModule() {
ST_DEBUG("begin processModule!\n");

// Add all of the unnamed global variables to the value table.
for (const GlobalVariable &Var : TheModule->globals()) {
  if (!Var.hasName())
    CreateModuleSlot(&Var);
  processGlobalObjectMetadata(Var);
  auto Attrs = Var.getAttributes();
  if (Attrs.hasAttributes())
    CreateAttributeSetSlot(Attrs);
}

for (const GlobalAlias &A : TheModule->aliases()) {
  if (!A.hasName())
    CreateModuleSlot(&A);
}

for (const GlobalIFunc &I : TheModule->ifuncs()) {
  if (!I.hasName())
    CreateModuleSlot(&I);
}

// Add metadata used by named metadata.
for (const NamedMDNode &NMD : TheModule->named_metadata()) {
  for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
    CreateMetadataSlot(NMD.getOperand(i));
}

for (const Function &F : *TheModule) {
  if (!F.hasName())
    // Add all the unnamed functions to the table.
    CreateModuleSlot(&F);

  if (ShouldInitializeAllMetadata)
    processFunctionMetadata(F);

  // Add all the function attributes to the table.
  // FIXME: Add attributes of other objects?
  AttributeSet FnAttrs = F.getAttributes().getFnAttributes();
  if (FnAttrs.hasAttributes())
    CreateAttributeSetSlot(FnAttrs);
}

if (ProcessModuleHookFn)
  ProcessModuleHookFn(this, TheModule, ShouldInitializeAllMetadata);

ST_DEBUG("end processModule!\n");
1000}

1002// Process the arguments, basic blocks, and instructions  of a function.
1003void SlotTracker::processFunction() {
ST_DEBUG("begin processFunction!\n");
fNext = 0;

// Process function metadata if it wasn't hit at the module-level.
if (!ShouldInitializeAllMetadata)
  processFunctionMetadata(*TheFunction);

// Add all the function arguments with no names.
for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
    AE = TheFunction->arg_end(); AI != AE; ++AI)
  if (!AI->hasName())
    CreateFunctionSlot(&*AI);

ST_DEBUG("Inserting Instructions:\n");

// Add all of the basic blocks and instructions with no names.
for (auto &BB : *TheFunction) {
  if (!BB.hasName())
    CreateFunctionSlot(&BB);

  for (auto &I : BB) {
    if (!I.getType()->isVoidTy() && !I.hasName())
      CreateFunctionSlot(&I);

    // We allow direct calls to any llvm.foo function here, because the
    // target may not be linked into the optimizer.
    if (const auto *Call = dyn_cast<CallBase>(&I)) {
      // Add all the call attributes to the table.
      AttributeSet Attrs = Call->getAttributes().getFnAttributes();
      if (Attrs.hasAttributes())
        CreateAttributeSetSlot(Attrs);
    }
  }
}

if (ProcessFunctionHookFn)
  ProcessFunctionHookFn(this, TheFunction, ShouldInitializeAllMetadata);

FunctionProcessed = true;

ST_DEBUG("end processFunction!\n");
1045}

1047// Iterate through all the GUID in the index and create slots for them.
1048int SlotTracker::processIndex() {
ST_DEBUG("begin processIndex!\n");
assert(TheIndex)((void)0);

// The first block of slots are just the module ids, which start at 0 and are
// assigned consecutively. Since the StringMap iteration order isn't
// guaranteed, use a std::map to order by module ID before assigning slots.
std::map<uint64_t, StringRef> ModuleIdToPathMap;
for (auto &ModPath : TheIndex->modulePaths())
  ModuleIdToPathMap[ModPath.second.first] = ModPath.first();
for (auto &ModPair : ModuleIdToPathMap)
  CreateModulePathSlot(ModPair.second);

// Start numbering the GUIDs after the module ids.
GUIDNext = ModulePathNext;

for (auto &GlobalList : *TheIndex)
  CreateGUIDSlot(GlobalList.first);

for (auto &TId : TheIndex->typeIdCompatibleVtableMap())
  CreateGUIDSlot(GlobalValue::getGUID(TId.first));

// Start numbering the TypeIds after the GUIDs.
TypeIdNext = GUIDNext;
for (const auto &TID : TheIndex->typeIds())
  CreateTypeIdSlot(TID.second.first);

ST_DEBUG("end processIndex!\n");
return TypeIdNext;
1077}

1079void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
GO.getAllMetadata(MDs);
for (auto &MD : MDs)
  CreateMetadataSlot(MD.second);
1084}

1086void SlotTracker::processFunctionMetadata(const Function &F) {
processGlobalObjectMetadata(F);
for (auto &BB : F) {
  for (auto &I : BB)
    processInstructionMetadata(I);
}
1092}

1094void SlotTracker::processInstructionMetadata(const Instruction &I) {
// Process metadata used directly by intrinsics.
if (const CallInst *CI = dyn_cast<CallInst>(&I))
  if (Function *F = CI->getCalledFunction())
    if (F->isIntrinsic())
      for (auto &Op : I.operands())
        if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
          if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
            CreateMetadataSlot(N);

// Process metadata attached to this instruction.
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
I.getAllMetadata(MDs);
for (auto &MD : MDs)
  CreateMetadataSlot(MD.second);
1109}

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.
1114void SlotTracker::purgeFunction() {
ST_DEBUG("begin purgeFunction!\n");
fMap.clear(); // Simply discard the function level map
TheFunction = nullptr;
FunctionProcessed = false;
ST_DEBUG("end purgeFunction!\n");
1120}

1122/// getGlobalSlot - Get the slot number of a global value.
1123int SlotTracker::getGlobalSlot(const GlobalValue *V) {
// Check for uninitialized state and do lazy initialization.
initializeIfNeeded();

// Find the value in the module map
ValueMap::iterator MI = mMap.find(V);
return MI == mMap.end() ? -1 : (int)MI->second;
1130}

1132void SlotTracker::setProcessHook(
  std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
      Fn) {
ProcessModuleHookFn = Fn;
1136}

1138void SlotTracker::setProcessHook(
  std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
      Fn) {
ProcessFunctionHookFn = Fn;
1142}

1144/// getMetadataSlot - Get the slot number of a MDNode.
1145void SlotTracker::createMetadataSlot(const MDNode *N) { CreateMetadataSlot(N); }

1147/// getMetadataSlot - Get the slot number of a MDNode.
1148int SlotTracker::getMetadataSlot(const MDNode *N) {
// Check for uninitialized state and do lazy initialization.
initializeIfNeeded();

// Find the MDNode in the module map
mdn_iterator MI = mdnMap.find(N);
return MI == mdnMap.end() ? -1 : (int)MI->second;
1155}

1157/// getLocalSlot - Get the slot number for a value that is local to a function.
1158int SlotTracker::getLocalSlot(const Value *V) {
assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!")((void)0);

// Check for uninitialized state and do lazy initialization.
initializeIfNeeded();

ValueMap::iterator FI = fMap.find(V);
return FI == fMap.end() ? -1 : (int)FI->second;
1166}

1168int SlotTracker::getAttributeGroupSlot(AttributeSet AS) {
// Check for uninitialized state and do lazy initialization.
initializeIfNeeded();

// Find the AttributeSet in the module map.
as_iterator AI = asMap.find(AS);
return AI == asMap.end() ? -1 : (int)AI->second;
1175}

1177int SlotTracker::getModulePathSlot(StringRef Path) {
// Check for uninitialized state and do lazy initialization.
initializeIndexIfNeeded();

// Find the Module path in the map
auto I = ModulePathMap.find(Path);
return I == ModulePathMap.end() ? -1 : (int)I->second;
1184}

1186int SlotTracker::getGUIDSlot(GlobalValue::GUID GUID) {
// Check for uninitialized state and do lazy initialization.
initializeIndexIfNeeded();

// Find the GUID in the map
guid_iterator I = GUIDMap.find(GUID);
return I == GUIDMap.end() ? -1 : (int)I->second;
1193}

1195int SlotTracker::getTypeIdSlot(StringRef Id) {
// Check for uninitialized state and do lazy initialization.
initializeIndexIfNeeded();

// Find the TypeId string in the map
auto I = TypeIdMap.find(Id);
return I == TypeIdMap.end() ? -1 : (int)I->second;
1202}

1204/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
1205void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
assert(V && "Can't insert a null Value into SlotTracker!")((void)0);
assert(!V->getType()->isVoidTy() && "Doesn't need a slot!")((void)0);
assert(!V->hasName() && "Doesn't need a slot!")((void)0);

unsigned DestSlot = mNext++;
mMap[V] = DestSlot;

ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
         DestSlot << " [");
// G = Global, F = Function, A = Alias, I = IFunc, o = other
ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
          (isa<Function>(V) ? 'F' :
           (isa<GlobalAlias>(V) ? 'A' :
            (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
1220}

1222/// CreateSlot - Create a new slot for the specified value if it has no name.
1223void SlotTracker::CreateFunctionSlot(const Value *V) {
assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!")((void)0);

unsigned DestSlot = fNext++;
fMap[V] = DestSlot;

// G = Global, F = Function, o = other
ST_DEBUG("  Inserting value [" << V->getType() << "] = " << V << " slot=" <<
         DestSlot << " [o]\n");
1232}

1234/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
1235void SlotTracker::CreateMetadataSlot(const MDNode *N) {
assert(N && "Can't insert a null Value into SlotTracker!")((void)0);

// Don't make slots for DIExpressions or DIArgLists. We just print them inline
// everywhere.
if (isa<DIExpression>(N) || isa<DIArgList>(N))
  return;

unsigned DestSlot = mdnNext;
if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
  return;
++mdnNext;

// Recursively add any MDNodes referenced by operands.
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
  if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
    CreateMetadataSlot(Op);
1252}

1254void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
assert(AS.hasAttributes() && "Doesn't need a slot!")((void)0);

as_iterator I = asMap.find(AS);
if (I != asMap.end())
  return;

unsigned DestSlot = asNext++;
asMap[AS] = DestSlot;
1263}

1265/// Create a new slot for the specified Module
1266void SlotTracker::CreateModulePathSlot(StringRef Path) {
ModulePathMap[Path] = ModulePathNext++;
1268}

1270/// Create a new slot for the specified GUID
1271void SlotTracker::CreateGUIDSlot(GlobalValue::GUID GUID) {
GUIDMap[GUID] = GUIDNext++;
1273}

1275/// Create a new slot for the specified Id
1276void SlotTracker::CreateTypeIdSlot(StringRef Id) {
TypeIdMap[Id] = TypeIdNext++;
1278}

1280//===----------------------------------------------------------------------===//
1281// AsmWriter Implementation
1282//===----------------------------------------------------------------------===//

1284static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine,
                                 const Module *Context);

1289static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine, const Module *Context,
                                 bool FromValue = false);

1294static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
  // 'Fast' is an abbreviation for all fast-math-flags.
  if (FPO->isFast())
    Out << " fast";
  else {
    if (FPO->hasAllowReassoc())
      Out << " reassoc";
    if (FPO->hasNoNaNs())
      Out << " nnan";
    if (FPO->hasNoInfs())
      Out << " ninf";
    if (FPO->hasNoSignedZeros())
      Out << " nsz";
    if (FPO->hasAllowReciprocal())
      Out << " arcp";
    if (FPO->hasAllowContract())
      Out << " contract";
    if (FPO->hasApproxFunc())
      Out << " afn";
  }
}

if (const OverflowingBinaryOperator *OBO =
      dyn_cast<OverflowingBinaryOperator>(U)) {
  if (OBO->hasNoUnsignedWrap())
    Out << " nuw";
  if (OBO->hasNoSignedWrap())
    Out << " nsw";
} else if (const PossiblyExactOperator *Div =
             dyn_cast<PossiblyExactOperator>(U)) {
  if (Div->isExact())
    Out << " exact";
} else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
  if (GEP->isInBounds())
    Out << " inbounds";
}
1331}

1333static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
                                TypePrinting &TypePrinter,
                                SlotTracker *Machine,
                                const Module *Context) {
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
  if (CI->getType()->isIntegerTy(1)) {
    Out << (CI->getZExtValue() ? "true" : "false");
    return;
  }
  Out << CI->getValue();
  return;
}

if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
  const APFloat &APF = CFP->getValueAPF();
  if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
      &APF.getSemantics() == &APFloat::IEEEdouble()) {
    // We would like to output the FP constant value in exponential notation,
    // but we cannot do this if doing so will lose precision.  Check here to
    // make sure that we only output it in exponential format if we can parse
    // the value back and get the same value.
    //
    bool ignored;
    bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
    bool isInf = APF.isInfinity();
    bool isNaN = APF.isNaN();
    if (!isInf && !isNaN) {
      double Val = APF.convertToDouble();
      SmallString<128> StrVal;
      APF.toString(StrVal, 6, 0, false);
      // Check to make sure that the stringized number is not some string like
      // "Inf" or NaN, that atof will accept, but the lexer will not.  Check
      // that the string matches the "[-+]?[0-9]" regex.
      //
      assert((isDigit(StrVal[0]) || ((StrVal[0] == '-' || StrVal[0] == '+') &&((void)0)
                                     isDigit(StrVal[1]))) &&((void)0)
             "[-+]?[0-9] regex does not match!")((void)0);
      // Reparse stringized version!
      if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
        Out << StrVal;
        return;
      }
    }
    // Otherwise we could not reparse it to exactly the same value, so we must
    // output the string in hexadecimal format!  Note that loading and storing
    // floating point types changes the bits of NaNs on some hosts, notably
    // x86, so we must not use these types.
    static_assert(sizeof(double) == sizeof(uint64_t),
                  "assuming that double is 64 bits!");
    APFloat apf = APF;
    // Floats are represented in ASCII IR as double, convert.
    // FIXME: We should allow 32-bit hex float and remove this.
    if (!isDouble) {
      // A signaling NaN is quieted on conversion, so we need to recreate the
      // expected value after convert (quiet bit of the payload is clear).
      bool IsSNAN = apf.isSignaling();
      apf.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                  &ignored);
      if (IsSNAN) {
        APInt Payload = apf.bitcastToAPInt();
        apf = APFloat::getSNaN(APFloat::IEEEdouble(), apf.isNegative(),
                               &Payload);
      }
    }
    Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
    return;
  }

  // Either half, bfloat or some form of long double.
  // These appear as a magic letter identifying the type, then a
  // fixed number of hex digits.
  Out << "0x";
  APInt API = APF.bitcastToAPInt();
  if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
    Out << 'K';
    Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
                                /*Upper=*/true);
    Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
                                /*Upper=*/true);
    return;
  } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
    Out << 'L';
    Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
                                /*Upper=*/true);
    Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
                                /*Upper=*/true);
  } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
    Out << 'M';
    Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
                                /*Upper=*/true);
    Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
                                /*Upper=*/true);
  } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
    Out << 'H';
    Out << format_hex_no_prefix(API.getZExtValue(), 4,
                                /*Upper=*/true);
  } else if (&APF.getSemantics() == &APFloat::BFloat()) {
    Out << 'R';
    Out << format_hex_no_prefix(API.getZExtValue(), 4,
                                /*Upper=*/true);
  } else
    llvm_unreachable("Unsupported floating point type")__builtin_unreachable();
  return;
}

if (isa<ConstantAggregateZero>(CV)) {
  Out << "zeroinitializer";
  return;
}

if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
  Out << "blockaddress(";
  WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
                         Context);
  Out << ", ";
  WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
                         Context);
  Out << ")";
  return;
}

if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) {
  Out << "dso_local_equivalent ";
  WriteAsOperandInternal(Out, Equiv->getGlobalValue(), &TypePrinter, Machine,
                         Context);
  return;
}

if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
  Type *ETy = CA->getType()->getElementType();
  Out << '[';
  TypePrinter.print(ETy, Out);
  Out << ' ';
  WriteAsOperandInternal(Out, CA->getOperand(0),
                         &TypePrinter, Machine,
                         Context);
  for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
    Out << ", ";
    TypePrinter.print(ETy, Out);
    Out << ' ';
    WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
                           Context);
  }
  Out << ']';
  return;
}

if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
  // As a special case, print the array as a string if it is an array of
  // i8 with ConstantInt values.
  if (CA->isString()) {
    Out << "c\"";
    printEscapedString(CA->getAsString(), Out);
    Out << '"';
    return;
  }

  Type *ETy = CA->getType()->getElementType();
  Out << '[';
  TypePrinter.print(ETy, Out);
  Out << ' ';
  WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
                         &TypePrinter, Machine,
                         Context);
  for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
    Out << ", ";
    TypePrinter.print(ETy, Out);
    Out << ' ';
    WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
                           Machine, Context);
  }
  Out << ']';
  return;
}

if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
  if (CS->getType()->isPacked())
    Out << '<';
  Out << '{';
  unsigned N = CS->getNumOperands();
  if (N) {
    Out << ' ';
    TypePrinter.print(CS->getOperand(0)->getType(), Out);
    Out << ' ';

    WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
                           Context);

    for (unsigned i = 1; i < N; i++) {
      Out << ", ";
      TypePrinter.print(CS->getOperand(i)->getType(), Out);
      Out << ' ';

      WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
                             Context);
    }
    Out << ' ';
  }

  Out << '}';
  if (CS->getType()->isPacked())
    Out << '>';
  return;
}

if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
  auto *CVVTy = cast<FixedVectorType>(CV->getType());
  Type *ETy = CVVTy->getElementType();
  Out << '<';
  TypePrinter.print(ETy, Out);
  Out << ' ';
  WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
                         Machine, Context);
  for (unsigned i = 1, e = CVVTy->getNumElements(); i != e; ++i) {
    Out << ", ";
    TypePrinter.print(ETy, Out);
    Out << ' ';
    WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
                           Machine, Context);
  }
  Out << '>';
  return;
}

if (isa<ConstantPointerNull>(CV)) {
  Out << "null";
  return;
}

if (isa<ConstantTokenNone>(CV)) {
  Out << "none";
  return;
}

if (isa<PoisonValue>(CV)) {
  Out << "poison";
  return;
}

if (isa<UndefValue>(CV)) {
  Out << "undef";
  return;
}

if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
  Out << CE->getOpcodeName();
  WriteOptimizationInfo(Out, CE);
  if (CE->isCompare())
    Out << ' ' << CmpInst::getPredicateName(
                      static_cast<CmpInst::Predicate>(CE->getPredicate()));
  Out << " (";

  Optional<unsigned> InRangeOp;
  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
    TypePrinter.print(GEP->getSourceElementType(), Out);
    Out << ", ";
    InRangeOp = GEP->getInRangeIndex();
    if (InRangeOp)
      ++*InRangeOp;
  }

  for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
    if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
      Out << "inrange ";
    TypePrinter.print((*OI)->getType(), Out);
    Out << ' ';
    WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
    if (OI+1 != CE->op_end())
      Out << ", ";
  }

  if (CE->hasIndices()) {
    ArrayRef<unsigned> Indices = CE->getIndices();
    for (unsigned i = 0, e = Indices.size(); i != e; ++i)
      Out << ", " << Indices[i];
  }

  if (CE->isCast()) {
    Out << " to ";
    TypePrinter.print(CE->getType(), Out);
  }

  if (CE->getOpcode() == Instruction::ShuffleVector)
    PrintShuffleMask(Out, CE->getType(), CE->getShuffleMask());

  Out << ')';
  return;
}

Out << "<placeholder or erroneous Constant>";
1623}

1625static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
                       TypePrinting *TypePrinter, SlotTracker *Machine,
                       const Module *Context) {
Out << "!{";
for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
  const Metadata *MD = Node->getOperand(mi);
  if (!MD)
    Out << "null";
  else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
    Value *V = MDV->getValue();
    TypePrinter->print(V->getType(), Out);
    Out << ' ';
    WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
  } else {
    WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
  }
  if (mi + 1 != me)
    Out << ", ";
}

Out << "}";
1646}

1648namespace {

1650struct FieldSeparator {
bool Skip = true;
const char *Sep;

FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
1655};

1657raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
if (FS.Skip) {
  FS.Skip = false;
  return OS;
}
return OS << FS.Sep;
1663}

1665struct MDFieldPrinter {
raw_ostream &Out;
FieldSeparator FS;
TypePrinting *TypePrinter = nullptr;
SlotTracker *Machine = nullptr;
const Module *Context = nullptr;

explicit MDFieldPrinter(raw_ostream &Out) : Out(Out) {}
MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
               SlotTracker *Machine, const Module *Context)
    : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
}

void printTag(const DINode *N);
void printMacinfoType(const DIMacroNode *N);
void printChecksum(const DIFile::ChecksumInfo<StringRef> &N);
void printString(StringRef Name, StringRef Value,
                 bool ShouldSkipEmpty = true);
void printMetadata(StringRef Name, const Metadata *MD,
                   bool ShouldSkipNull = true);
template <class IntTy>
void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
void printAPInt(StringRef Name, const APInt &Int, bool IsUnsigned,
                bool ShouldSkipZero);
void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
void printDIFlags(StringRef Name, DINode::DIFlags Flags);
void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
template <class IntTy, class Stringifier>
void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
                    bool ShouldSkipZero = true);
void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
void printNameTableKind(StringRef Name,
                        DICompileUnit::DebugNameTableKind NTK);
1698};

1700} // end anonymous namespace

1702void MDFieldPrinter::printTag(const DINode *N) {
Out << FS << "tag: ";
auto Tag = dwarf::TagString(N->getTag());
if (!Tag.empty())
  Out << Tag;
else
  Out << N->getTag();
1709}

1711void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
Out << FS << "type: ";
auto Type = dwarf::MacinfoString(N->getMacinfoType());
if (!Type.empty())
  Out << Type;
else
  Out << N->getMacinfoType();
1718}

1720void MDFieldPrinter::printChecksum(
  const DIFile::ChecksumInfo<StringRef> &Checksum) {
Out << FS << "checksumkind: " << Checksum.getKindAsString();
printString("checksum", Checksum.Value, /* ShouldSkipEmpty */ false);
1724}

1726void MDFieldPrinter::printString(StringRef Name, StringRef Value,
                               bool ShouldSkipEmpty) {
if (ShouldSkipEmpty && Value.empty())
  return;

Out << FS << Name << ": \"";
printEscapedString(Value, Out);
Out << "\"";
1734}

1736static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine,
                                 const Module *Context) {
if (!MD) {
  Out << "null";
  return;
}
WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1745}

1747void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
                                 bool ShouldSkipNull) {
if (ShouldSkipNull && !MD)
  return;

Out << FS << Name << ": ";
writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1754}

1756template <class IntTy>
1757void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
if (ShouldSkipZero && !Int)
  return;

Out << FS << Name << ": " << Int;
1762}

1764void MDFieldPrinter::printAPInt(StringRef Name, const APInt &Int,
                              bool IsUnsigned, bool ShouldSkipZero) {
if (ShouldSkipZero && Int.isNullValue())
  return;

Out << FS << Name << ": ";
Int.print(Out, !IsUnsigned);
1771}

1773void MDFieldPrinter::printBool(StringRef Name, bool Value,
                             Optional<bool> Default) {
if (Default && Value == *Default)
  return;
Out << FS << Name << ": " << (Value ? "true" : "false");
1778}

1780void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
if (!Flags)
  return;

Out << FS << Name << ": ";

SmallVector<DINode::DIFlags, 8> SplitFlags;
auto Extra = DINode::splitFlags(Flags, SplitFlags);

FieldSeparator FlagsFS(" | ");
for (auto F : SplitFlags) {
  auto StringF = DINode::getFlagString(F);
  assert(!StringF.empty() && "Expected valid flag")((void)0);
  Out << FlagsFS << StringF;
}
if (Extra || SplitFlags.empty())
  Out << FlagsFS << Extra;
1797}

1799void MDFieldPrinter::printDISPFlags(StringRef Name,
                                  DISubprogram::DISPFlags Flags) {
// Always print this field, because no flags in the IR at all will be
// interpreted as old-style isDefinition: true.
Out << FS << Name << ": ";

if (!Flags) {
  Out << 0;
  return;
}

SmallVector<DISubprogram::DISPFlags, 8> SplitFlags;
auto Extra = DISubprogram::splitFlags(Flags, SplitFlags);

FieldSeparator FlagsFS(" | ");
for (auto F : SplitFlags) {
  auto StringF = DISubprogram::getFlagString(F);
  assert(!StringF.empty() && "Expected valid flag")((void)0);
  Out << FlagsFS << StringF;
}
if (Extra || SplitFlags.empty())
  Out << FlagsFS << Extra;
1821}

1823void MDFieldPrinter::printEmissionKind(StringRef Name,
                                     DICompileUnit::DebugEmissionKind EK) {
Out << FS << Name << ": " << DICompileUnit::emissionKindString(EK);
1826}

1828void MDFieldPrinter::printNameTableKind(StringRef Name,
                                      DICompileUnit::DebugNameTableKind NTK) {
if (NTK == DICompileUnit::DebugNameTableKind::Default)
  return;
Out << FS << Name << ": " << DICompileUnit::nameTableKindString(NTK);
1833}

1835template <class IntTy, class Stringifier>
1836void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
                                  Stringifier toString, bool ShouldSkipZero) {
if (!Value)
  return;

Out << FS << Name << ": ";
auto S = toString(Value);
if (!S.empty())
  Out << S;
else
  Out << Value;
1847}

1849static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
                             TypePrinting *TypePrinter, SlotTracker *Machine,
                             const Module *Context) {
Out << "!GenericDINode(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printTag(N);
Printer.printString("header", N->getHeader());
if (N->getNumDwarfOperands()) {
  Out << Printer.FS << "operands: {";
  FieldSeparator IFS;
  for (auto &I : N->dwarf_operands()) {
    Out << IFS;
    writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
  }
  Out << "}";
}
Out << ")";
1866}

1868static void writeDILocation(raw_ostream &Out, const DILocation *DL,
                          TypePrinting *TypePrinter, SlotTracker *Machine,
                          const Module *Context) {
Out << "!DILocation(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
// Always output the line, since 0 is a relevant and important value for it.
Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
Printer.printInt("column", DL->getColumn());
Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
Printer.printBool("isImplicitCode", DL->isImplicitCode(),
                  /* Default */ false);
Out << ")";
1881}

1883static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
                          TypePrinting *TypePrinter, SlotTracker *Machine,
                          const Module *Context) {
Out << "!DISubrange(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

auto *Count = N->getRawCountNode();
if (auto *CE = dyn_cast_or_null<ConstantAsMetadata>(Count)) {
  auto *CV = cast<ConstantInt>(CE->getValue());
  Printer.printInt("count", CV->getSExtValue(),
                   /* ShouldSkipZero */ false);
} else
  Printer.printMetadata("count", Count, /*ShouldSkipNull */ true);

// A lowerBound of constant 0 should not be skipped, since it is different
// from an unspecified lower bound (= nullptr).
auto *LBound = N->getRawLowerBound();
if (auto *LE = dyn_cast_or_null<ConstantAsMetadata>(LBound)) {
  auto *LV = cast<ConstantInt>(LE->getValue());
  Printer.printInt("lowerBound", LV->getSExtValue(),
                   /* ShouldSkipZero */ false);
} else
  Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true);

auto *UBound = N->getRawUpperBound();
if (auto *UE = dyn_cast_or_null<ConstantAsMetadata>(UBound)) {
  auto *UV = cast<ConstantInt>(UE->getValue());
  Printer.printInt("upperBound", UV->getSExtValue(),
                   /* ShouldSkipZero */ false);
} else
  Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true);

auto *Stride = N->getRawStride();
if (auto *SE = dyn_cast_or_null<ConstantAsMetadata>(Stride)) {
  auto *SV = cast<ConstantInt>(SE->getValue());
  Printer.printInt("stride", SV->getSExtValue(), /* ShouldSkipZero */ false);
} else
  Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true);

Out << ")";
1923}

1925static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine,
                                 const Module *Context) {
Out << "!DIGenericSubrange(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

auto IsConstant = [&](Metadata *Bound) -> bool {
  if (auto *BE = dyn_cast_or_null<DIExpression>(Bound)) {
    return BE->isConstant()
               ? DIExpression::SignedOrUnsignedConstant::SignedConstant ==
                     *BE->isConstant()
               : false;
  }
  return false;
};

auto GetConstant = [&](Metadata *Bound) -> int64_t {
  assert(IsConstant(Bound) && "Expected constant")((void)0);
  auto *BE = dyn_cast_or_null<DIExpression>(Bound);
31
←
Assuming null pointer is passed into cast→
32
←
'BE' initialized to a null pointer value→
  return static_cast<int64_t>(BE->getElement(1));
33
←
Called C++ object pointer is null
};

auto *Count = N->getRawCountNode();
if (IsConstant(Count))
28
←
Assuming the condition is true→
29
←
Taking true branch→
  Printer.printInt("count", GetConstant(Count),
30
←
Calling 'operator()'→
                   /* ShouldSkipZero */ false);
else
  Printer.printMetadata("count", Count, /*ShouldSkipNull */ true);

auto *LBound = N->getRawLowerBound();
if (IsConstant(LBound))
  Printer.printInt("lowerBound", GetConstant(LBound),
                   /* ShouldSkipZero */ false);
else
  Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true);

auto *UBound = N->getRawUpperBound();
if (IsConstant(UBound))
  Printer.printInt("upperBound", GetConstant(UBound),
                   /* ShouldSkipZero */ false);
else
  Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true);

auto *Stride = N->getRawStride();
if (IsConstant(Stride))
  Printer.printInt("stride", GetConstant(Stride),
                   /* ShouldSkipZero */ false);
else
  Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true);

Out << ")";
1977}

1979static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
                            TypePrinting *, SlotTracker *, const Module *) {
Out << "!DIEnumerator(";
MDFieldPrinter Printer(Out);
Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
Printer.printAPInt("value", N->getValue(), N->isUnsigned(),
                   /*ShouldSkipZero=*/false);
if (N->isUnsigned())
  Printer.printBool("isUnsigned", true);
Out << ")";
1989}

1991static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
                           TypePrinting *, SlotTracker *, const Module *) {
Out << "!DIBasicType(";
MDFieldPrinter Printer(Out);
if (N->getTag() != dwarf::DW_TAG_base_type)
  Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printInt("size", N->getSizeInBits());
Printer.printInt("align", N->getAlignInBits());
Printer.printDwarfEnum("encoding", N->getEncoding(),
                       dwarf::AttributeEncodingString);
Printer.printDIFlags("flags", N->getFlags());
Out << ")";
2004}

2006static void writeDIStringType(raw_ostream &Out, const DIStringType *N,
                            TypePrinting *TypePrinter, SlotTracker *Machine,
                            const Module *Context) {
Out << "!DIStringType(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
if (N->getTag() != dwarf::DW_TAG_string_type)
  Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printMetadata("stringLength", N->getRawStringLength());
Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp());
Printer.printInt("size", N->getSizeInBits());
Printer.printInt("align", N->getAlignInBits());
Printer.printDwarfEnum("encoding", N->getEncoding(),
                       dwarf::AttributeEncodingString);
Out << ")";
2021}

2023static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
                             TypePrinting *TypePrinter, SlotTracker *Machine,
                             const Module *Context) {
Out << "!DIDerivedType(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printMetadata("scope", N->getRawScope());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printMetadata("baseType", N->getRawBaseType(),
                      /* ShouldSkipNull */ false);
Printer.printInt("size", N->getSizeInBits());
Printer.printInt("align", N->getAlignInBits());
Printer.printInt("offset", N->getOffsetInBits());
Printer.printDIFlags("flags", N->getFlags());
Printer.printMetadata("extraData", N->getRawExtraData());
if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
  Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
                   /* ShouldSkipZero */ false);
Out << ")";
2044}

2046static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
                               TypePrinting *TypePrinter,
                               SlotTracker *Machine, const Module *Context) {
Out << "!DICompositeType(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printMetadata("scope", N->getRawScope());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printMetadata("baseType", N->getRawBaseType());
Printer.printInt("size", N->getSizeInBits());
Printer.printInt("align", N->getAlignInBits());
Printer.printInt("offset", N->getOffsetInBits());
Printer.printDIFlags("flags", N->getFlags());
Printer.printMetadata("elements", N->getRawElements());
Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
                       dwarf::LanguageString);
Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
Printer.printMetadata("templateParams", N->getRawTemplateParams());
Printer.printString("identifier", N->getIdentifier());
Printer.printMetadata("discriminator", N->getRawDiscriminator());
Printer.printMetadata("dataLocation", N->getRawDataLocation());
Printer.printMetadata("associated", N->getRawAssociated());
Printer.printMetadata("allocated", N->getRawAllocated());
if (auto *RankConst = N->getRankConst())
  Printer.printInt("rank", RankConst->getSExtValue(),
                   /* ShouldSkipZero */ false);
else
  Printer.printMetadata("rank", N->getRawRank(), /*ShouldSkipNull */ true);
Out << ")";
2077}

2079static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
                                TypePrinting *TypePrinter,
                                SlotTracker *Machine, const Module *Context) {
Out << "!DISubroutineType(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printDIFlags("flags", N->getFlags());
Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
Printer.printMetadata("types", N->getRawTypeArray(),
                      /* ShouldSkipNull */ false);
Out << ")";
2089}

2091static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
                      SlotTracker *, const Module *) {
Out << "!DIFile(";
MDFieldPrinter Printer(Out);
Printer.printString("filename", N->getFilename(),
                    /* ShouldSkipEmpty */ false);
Printer.printString("directory", N->getDirectory(),
                    /* ShouldSkipEmpty */ false);
// Print all values for checksum together, or not at all.
if (N->getChecksum())
  Printer.printChecksum(*N->getChecksum());
Printer.printString("source", N->getSource().getValueOr(StringRef()),
                    /* ShouldSkipEmpty */ true);
Out << ")";
2105}

2107static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
                             TypePrinting *TypePrinter, SlotTracker *Machine,
                             const Module *Context) {
Out << "!DICompileUnit(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printDwarfEnum("language", N->getSourceLanguage(),
                       dwarf::LanguageString, /* ShouldSkipZero */ false);
Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
Printer.printString("producer", N->getProducer());
Printer.printBool("isOptimized", N->isOptimized());
Printer.printString("flags", N->getFlags());
Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
                 /* ShouldSkipZero */ false);
Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
Printer.printEmissionKind("emissionKind", N->getEmissionKind());
Printer.printMetadata("enums", N->getRawEnumTypes());
Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
Printer.printMetadata("globals", N->getRawGlobalVariables());
Printer.printMetadata("imports", N->getRawImportedEntities());
Printer.printMetadata("macros", N->getRawMacros());
Printer.printInt("dwoId", N->getDWOId());
Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
                  false);
Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
Printer.printString("sysroot", N->getSysRoot());
Printer.printString("sdk", N->getSDK());
Out << ")";
2136}

2138static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
                            TypePrinting *TypePrinter, SlotTracker *Machine,
                            const Module *Context) {
Out << "!DISubprogram(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printString("linkageName", N->getLinkageName());
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printMetadata("type", N->getRawType());
Printer.printInt("scopeLine", N->getScopeLine());
Printer.printMetadata("containingType", N->getRawContainingType());
if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
    N->getVirtualIndex() != 0)
  Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
Printer.printInt("thisAdjustment", N->getThisAdjustment());
Printer.printDIFlags("flags", N->getFlags());
Printer.printDISPFlags("spFlags", N->getSPFlags());
Printer.printMetadata("unit", N->getRawUnit());
Printer.printMetadata("templateParams", N->getRawTemplateParams());
Printer.printMetadata("declaration", N->getRawDeclaration());
Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
Out << ")";
2163}

2165static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
                              TypePrinting *TypePrinter, SlotTracker *Machine,
                              const Module *Context) {
Out << "!DILexicalBlock(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printInt("column", N->getColumn());
Out << ")";
2175}

2177static void writeDILexicalBlockFile(raw_ostream &Out,
                                  const DILexicalBlockFile *N,
                                  TypePrinting *TypePrinter,
                                  SlotTracker *Machine,
                                  const Module *Context) {
Out << "!DILexicalBlockFile(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("discriminator", N->getDiscriminator(),
                 /* ShouldSkipZero */ false);
Out << ")";
2189}

2191static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
                           TypePrinting *TypePrinter, SlotTracker *Machine,
                           const Module *Context) {
Out << "!DINamespace(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printBool("exportSymbols", N->getExportSymbols(), false);
Out << ")";
2200}

2202static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N,
                             TypePrinting *TypePrinter, SlotTracker *Machine,
                             const Module *Context) {
Out << "!DICommonBlock(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("scope", N->getRawScope(), false);
Printer.printMetadata("declaration", N->getRawDecl(), false);
Printer.printString("name", N->getName());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLineNo());
Out << ")";
2213}

2215static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
                       TypePrinting *TypePrinter, SlotTracker *Machine,
                       const Module *Context) {
Out << "!DIMacro(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMacinfoType(N);
Printer.printInt("line", N->getLine());
Printer.printString("name", N->getName());
Printer.printString("value", N->getValue());
Out << ")";
2225}

2227static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
                           TypePrinting *TypePrinter, SlotTracker *Machine,
                           const Module *Context) {
Out << "!DIMacroFile(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printInt("line", N->getLine());
Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
Printer.printMetadata("nodes", N->getRawElements());
Out << ")";
2236}

2238static void writeDIModule(raw_ostream &Out, const DIModule *N,
                        TypePrinting *TypePrinter, SlotTracker *Machine,
                        const Module *Context) {
Out << "!DIModule(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printString("name", N->getName());
Printer.printString("configMacros", N->getConfigurationMacros());
Printer.printString("includePath", N->getIncludePath());
Printer.printString("apinotes", N->getAPINotesFile());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLineNo());
Printer.printBool("isDecl", N->getIsDecl(), /* Default */ false);
Out << ")";
2252}


2255static void writeDITemplateTypeParameter(raw_ostream &Out,
                                       const DITemplateTypeParameter *N,
                                       TypePrinting *TypePrinter,
                                       SlotTracker *Machine,
                                       const Module *Context) {
Out << "!DITemplateTypeParameter(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
Out << ")";
2266}

2268static void writeDITemplateValueParameter(raw_ostream &Out,
                                        const DITemplateValueParameter *N,
                                        TypePrinting *TypePrinter,
                                        SlotTracker *Machine,
                                        const Module *Context) {
Out << "!DITemplateValueParameter(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
  Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printMetadata("type", N->getRawType());
Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
Out << ")";
2282}

2284static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
                                TypePrinting *TypePrinter,
                                SlotTracker *Machine, const Module *Context) {
Out << "!DIGlobalVariable(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printString("linkageName", N->getLinkageName());
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printMetadata("type", N->getRawType());
Printer.printBool("isLocal", N->isLocalToUnit());
Printer.printBool("isDefinition", N->isDefinition());
Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
Printer.printMetadata("templateParams", N->getRawTemplateParams());
Printer.printInt("align", N->getAlignInBits());
Out << ")";
2301}

2303static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
                               TypePrinting *TypePrinter,
                               SlotTracker *Machine, const Module *Context) {
Out << "!DILocalVariable(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printInt("arg", N->getArg());
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printMetadata("type", N->getRawType());
Printer.printDIFlags("flags", N->getFlags());
Printer.printInt("align", N->getAlignInBits());
Out << ")";
2317}

2319static void writeDILabel(raw_ostream &Out, const DILabel *N,
                       TypePrinting *TypePrinter,
                       SlotTracker *Machine, const Module *Context) {
Out << "!DILabel(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printString("name", N->getName());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Out << ")";
2329}

2331static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
                            TypePrinting *TypePrinter, SlotTracker *Machine,
                            const Module *Context) {
Out << "!DIExpression(";
FieldSeparator FS;
if (N->isValid()) {
  for (const DIExpression::ExprOperand &Op : N->expr_ops()) {
    auto OpStr = dwarf::OperationEncodingString(Op.getOp());
    assert(!OpStr.empty() && "Expected valid opcode")((void)0);

    Out << FS << OpStr;
    if (Op.getOp() == dwarf::DW_OP_LLVM_convert) {
      Out << FS << Op.getArg(0);
      Out << FS << dwarf::AttributeEncodingString(Op.getArg(1));
    } else {
      for (unsigned A = 0, AE = Op.getNumArgs(); A != AE; ++A)
        Out << FS << Op.getArg(A);
    }
  }
} else {
  for (const auto &I : N->getElements())
    Out << FS << I;
}
Out << ")";
2355}

2357static void writeDIArgList(raw_ostream &Out, const DIArgList *N,
                         TypePrinting *TypePrinter, SlotTracker *Machine,
                         const Module *Context, bool FromValue = false) {
assert(FromValue &&((void)0)
       "Unexpected DIArgList metadata outside of value argument")((void)0);
Out << "!DIArgList(";
FieldSeparator FS;
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
for (Metadata *Arg : N->getArgs()) {
  Out << FS;
  WriteAsOperandInternal(Out, Arg, TypePrinter, Machine, Context, true);
}
Out << ")";
2370}

2372static void writeDIGlobalVariableExpression(raw_ostream &Out,
                                          const DIGlobalVariableExpression *N,
                                          TypePrinting *TypePrinter,
                                          SlotTracker *Machine,
                                          const Module *Context) {
Out << "!DIGlobalVariableExpression(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printMetadata("var", N->getVariable());
Printer.printMetadata("expr", N->getExpression());
Out << ")";
2382}

2384static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
                              TypePrinting *TypePrinter, SlotTracker *Machine,
                              const Module *Context) {
Out << "!DIObjCProperty(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printString("name", N->getName());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Printer.printString("setter", N->getSetterName());
Printer.printString("getter", N->getGetterName());
Printer.printInt("attributes", N->getAttributes());
Printer.printMetadata("type", N->getRawType());
Out << ")";
2397}

2399static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
                                TypePrinting *TypePrinter,
                                SlotTracker *Machine, const Module *Context) {
Out << "!DIImportedEntity(";
MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
Printer.printTag(N);
Printer.printString("name", N->getName());
Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
Printer.printMetadata("entity", N->getRawEntity());
Printer.printMetadata("file", N->getRawFile());
Printer.printInt("line", N->getLine());
Out << ")";
2411}

2413static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
                                  TypePrinting *TypePrinter,
                                  SlotTracker *Machine,
                                  const Module *Context) {
if (Node->isDistinct())
23
←
Taking false branch→
  Out << "distinct ";
else if (Node->isTemporary())
24
←
Taking false branch→
  Out << "<temporary!> "; // Handle broken code.

switch (Node->getMetadataID()) {
25
←
Control jumps to 'case DIGenericSubrangeKind:'  at line 119→
default:
  llvm_unreachable("Expected uniquable MDNode")__builtin_unreachable();
2425#define HANDLE_MDNODE_LEAF(CLASS)                                              \
case Metadata::CLASS##Kind:                                                  \
  write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context);       \
  break;
2429#include "llvm/IR/Metadata.def"
}
2431}

2433// Full implementation of printing a Value as an operand with support for
2434// TypePrinting, etc.
2435static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine,
                                 const Module *Context) {
if (V->hasName()) {
  PrintLLVMName(Out, V);
  return;
}

const Constant *CV = dyn_cast<Constant>(V);
if (CV && !isa<GlobalValue>(CV)) {
  assert(TypePrinter && "Constants require TypePrinting!")((void)0);
  WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
  return;
}

if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
  Out << "asm ";
  if (IA->hasSideEffects())
    Out << "sideeffect ";
  if (IA->isAlignStack())
    Out << "alignstack ";
  // We don't emit the AD_ATT dialect as it's the assumed default.
  if (IA->getDialect() == InlineAsm::AD_Intel)
    Out << "inteldialect ";
  if (IA->canThrow())
    Out << "unwind ";
  Out << '"';
  printEscapedString(IA->getAsmString(), Out);
  Out << "\", \"";
  printEscapedString(IA->getConstraintString(), Out);
  Out << '"';
  return;
}

if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
  WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
                         Context, /* FromValue */ true);
  return;
}

char Prefix = '%';
int Slot;
// If we have a SlotTracker, use it.
if (Machine) {
  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
    Slot = Machine->getGlobalSlot(GV);
    Prefix = '@';
  } else {
    Slot = Machine->getLocalSlot(V);

    // If the local value didn't succeed, then we may be referring to a value
    // from a different function.  Translate it, as this can happen when using
    // address of blocks.
    if (Slot == -1)
      if ((Machine = createSlotTracker(V))) {
        Slot = Machine->getLocalSlot(V);
        delete Machine;
      }
  }
} else if ((Machine = createSlotTracker(V))) {
  // Otherwise, create one to get the # and then destroy it.
  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
    Slot = Machine->getGlobalSlot(GV);
    Prefix = '@';
  } else {
    Slot = Machine->getLocalSlot(V);
  }
  delete Machine;
  Machine = nullptr;
} else {
  Slot = -1;
}

if (Slot != -1)
  Out << Prefix << Slot;
else
  Out << "<badref>";
2513}

2515static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
                                 TypePrinting *TypePrinter,
                                 SlotTracker *Machine, const Module *Context,
                                 bool FromValue) {
// Write DIExpressions and DIArgLists inline when used as a value. Improves
// readability of debug info intrinsics.
if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
  writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
  return;
}
if (const DIArgList *ArgList = dyn_cast<DIArgList>(MD)) {
  writeDIArgList(Out, ArgList, TypePrinter, Machine, Context, FromValue);
  return;
}

if (const MDNode *N = dyn_cast<MDNode>(MD)) {
  std::unique_ptr<SlotTracker> MachineStorage;
  if (!Machine) {
    MachineStorage = std::make_unique<SlotTracker>(Context);
    Machine = MachineStorage.get();
  }
  int Slot = Machine->getMetadataSlot(N);
  if (Slot == -1) {
    if (const DILocation *Loc = dyn_cast<DILocation>(N)) {
      writeDILocation(Out, Loc, TypePrinter, Machine, Context);
      return;
    }
    // Give the pointer value instead of "badref", since this comes up all
    // the time when debugging.
    Out << "<" << N << ">";
  } else
    Out << '!' << Slot;
  return;
}

if (const MDString *MDS = dyn_cast<MDString>(MD)) {
  Out << "!\"";
  printEscapedString(MDS->getString(), Out);
  Out << '"';
  return;
}

auto *V = cast<ValueAsMetadata>(MD);
assert(TypePrinter && "TypePrinter required for metadata values")((void)0);
assert((FromValue || !isa<LocalAsMetadata>(V)) &&((void)0)
       "Unexpected function-local metadata outside of value argument")((void)0);

TypePrinter->print(V->getValue()->getType(), Out);
Out << ' ';
WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2565}

2567namespace {

2569class AssemblyWriter {
formatted_raw_ostream &Out;
const Module *TheModule = nullptr;
const ModuleSummaryIndex *TheIndex = nullptr;
std::unique_ptr<SlotTracker> SlotTrackerStorage;
SlotTracker &Machine;
TypePrinting TypePrinter;
AssemblyAnnotationWriter *AnnotationWriter = nullptr;
SetVector<const Comdat *> Comdats;
bool IsForDebug;
bool ShouldPreserveUseListOrder;
UseListOrderMap UseListOrders;
SmallVector<StringRef, 8> MDNames;
/// Synchronization scope names registered with LLVMContext.
SmallVector<StringRef, 8> SSNs;
DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;

2586public:
/// Construct an AssemblyWriter with an external SlotTracker
AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
               AssemblyAnnotationWriter *AAW, bool IsForDebug,
               bool ShouldPreserveUseListOrder = false);

AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
               const ModuleSummaryIndex *Index, bool IsForDebug);

void printMDNodeBody(const MDNode *MD);
void printNamedMDNode(const NamedMDNode *NMD);

void printModule(const Module *M);

void writeOperand(const Value *Op, bool PrintType);
void writeParamOperand(const Value *Operand, AttributeSet Attrs);
void writeOperandBundles(const CallBase *Call);
void writeSyncScope(const LLVMContext &Context,
                    SyncScope::ID SSID);
void writeAtomic(const LLVMContext &Context,
                 AtomicOrdering Ordering,
                 SyncScope::ID SSID);
void writeAtomicCmpXchg(const LLVMContext &Context,
                        AtomicOrdering SuccessOrdering,
                        AtomicOrdering FailureOrdering,
                        SyncScope::ID SSID);

void writeAllMDNodes();
void writeMDNode(unsigned Slot, const MDNode *Node);
void writeAttribute(const Attribute &Attr, bool InAttrGroup = false);
void writeAttributeSet(const AttributeSet &AttrSet, bool InAttrGroup = false);
void writeAllAttributeGroups();

void printTypeIdentities();
void printGlobal(const GlobalVariable *GV);
void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
void printComdat(const Comdat *C);
void printFunction(const Function *F);
void printArgument(const Argument *FA, AttributeSet Attrs);
void printBasicBlock(const BasicBlock *BB);
void printInstructionLine(const Instruction &I);
void printInstruction(const Instruction &I);

void printUseListOrder(const Value *V, const std::vector<unsigned> &Shuffle);
void printUseLists(const Function *F);

void printModuleSummaryIndex();
void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
void printSummary(const GlobalValueSummary &Summary);
void printAliasSummary(const AliasSummary *AS);
void printGlobalVarSummary(const GlobalVarSummary *GS);
void printFunctionSummary(const FunctionSummary *FS);
void printTypeIdSummary(const TypeIdSummary &TIS);
void printTypeIdCompatibleVtableSummary(const TypeIdCompatibleVtableInfo &TI);
void printTypeTestResolution(const TypeTestResolution &TTRes);
void printArgs(const std::vector<uint64_t> &Args);
void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
void printVFuncId(const FunctionSummary::VFuncId VFId);
void
printNonConstVCalls(const std::vector<FunctionSummary::VFuncId> &VCallList,
                    const char *Tag);
void
printConstVCalls(const std::vector<FunctionSummary::ConstVCall> &VCallList,
                 const char *Tag);

2652private:
/// Print out metadata attachments.
void printMetadataAttachments(
    const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
    StringRef Separator);

// printInfoComment - Print a little comment after the instruction indicating
// which slot it occupies.
void printInfoComment(const Value &V);

// printGCRelocateComment - print comment after call to the gc.relocate
// intrinsic indicating base and derived pointer names.
void printGCRelocateComment(const GCRelocateInst &Relocate);
2665};

2667} // end anonymous namespace

2669AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
                             const Module *M, AssemblyAnnotationWriter *AAW,
                             bool IsForDebug, bool ShouldPreserveUseListOrder)
  : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),
    IsForDebug(IsForDebug),
    ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
if (!TheModule)
  return;
for (const GlobalObject &GO : TheModule->global_objects())
  if (const Comdat *C = GO.getComdat())
    Comdats.insert(C);
2680}

2682AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
                             const ModuleSummaryIndex *Index, bool IsForDebug)
  : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(/*Module=*/nullptr),
    IsForDebug(IsForDebug), ShouldPreserveUseListOrder(false) {}

2687void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
if (!Operand) {
  Out << "<null operand!>";
  return;
}
if (PrintType) {
  TypePrinter.print(Operand->getType(), Out);
  Out << ' ';
}
WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2697}

2699void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
                                  SyncScope::ID SSID) {
switch (SSID) {
case SyncScope::System: {
  break;
}
default: {
  if (SSNs.empty())
    Context.getSyncScopeNames(SSNs);

  Out << " syncscope(\"";
  printEscapedString(SSNs[SSID], Out);
  Out << "\")";
  break;
}
}
2715}

2717void AssemblyWriter::writeAtomic(const LLVMContext &Context,
                               AtomicOrdering Ordering,
                               SyncScope::ID SSID) {
if (Ordering == AtomicOrdering::NotAtomic)
  return;

writeSyncScope(Context, SSID);
Out << " " << toIRString(Ordering);
2725}

2727void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
                                      AtomicOrdering SuccessOrdering,
                                      AtomicOrdering FailureOrdering,
                                      SyncScope::ID SSID) {
assert(SuccessOrdering != AtomicOrdering::NotAtomic &&((void)0)
       FailureOrdering != AtomicOrdering::NotAtomic)((void)0);

writeSyncScope(Context, SSID);
Out << " " << toIRString(SuccessOrdering);
Out << " " << toIRString(FailureOrdering);
2737}

2739void AssemblyWriter::writeParamOperand(const Value *Operand,
                                     AttributeSet Attrs) {
if (!Operand) {
  Out << "<null operand!>";
  return;
}

// Print the type
TypePrinter.print(Operand->getType(), Out);
// Print parameter attributes list
if (Attrs.hasAttributes()) {
  Out << ' ';
  writeAttributeSet(Attrs);
}
Out << ' ';
// Print the operand
WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2756}

2758void AssemblyWriter::writeOperandBundles(const CallBase *Call) {
if (!Call->hasOperandBundles())
  return;

Out << " [ ";

bool FirstBundle = true;
for (unsigned i = 0, e = Call->getNumOperandBundles(); i != e; ++i) {
  OperandBundleUse BU = Call->getOperandBundleAt(i);

  if (!FirstBundle)
    Out << ", ";
  FirstBundle = false;

  Out << '"';
  printEscapedString(BU.getTagName(), Out);
  Out << '"';

  Out << '(';

  bool FirstInput = true;
  for (const auto &Input : BU.Inputs) {
    if (!FirstInput)
      Out << ", ";
    FirstInput = false;

    TypePrinter.print(Input->getType(), Out);
    Out << " ";
    WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
  }

  Out << ')';
}

Out << " ]";
2793}

2795void AssemblyWriter::printModule(const Module *M) {
Machine.initializeIfNeeded();

if (ShouldPreserveUseListOrder)
  UseListOrders = predictUseListOrder(M);

if (!M->getModuleIdentifier().empty() &&
    // Don't print the ID if it will start a new line (which would
    // require a comment char before it).
    M->getModuleIdentifier().find('\n') == std::string::npos)
  Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";

if (!M->getSourceFileName().empty()) {
  Out << "source_filename = \"";
  printEscapedString(M->getSourceFileName(), Out);
  Out << "\"\n";
}

const std::string &DL = M->getDataLayoutStr();
if (!DL.empty())
  Out << "target datalayout = \"" << DL << "\"\n";
if (!M->getTargetTriple().empty())
  Out << "target triple = \"" << M->getTargetTriple() << "\"\n";

if (!M->getModuleInlineAsm().empty()) {
  Out << '\n';

  // Split the string into lines, to make it easier to read the .ll file.
  StringRef Asm = M->getModuleInlineAsm();
  do {
    StringRef Front;
    std::tie(Front, Asm) = Asm.split('\n');

    // We found a newline, print the portion of the asm string from the
    // last newline up to this newline.
    Out << "module asm \"";
    printEscapedString(Front, Out);
    Out << "\"\n";
  } while (!Asm.empty());
}

printTypeIdentities();

// Output all comdats.
if (!Comdats.empty())
  Out << '\n';
for (const Comdat *C : Comdats) {
  printComdat(C);
  if (C != Comdats.back())
    Out << '\n';
}

// Output all globals.
if (!M->global_empty()) Out << '\n';
for (const GlobalVariable &GV : M->globals()) {
  printGlobal(&GV); Out << '\n';
}

// Output all aliases.
if (!M->alias_empty()) Out << "\n";
for (const GlobalAlias &GA : M->aliases())
  printIndirectSymbol(&GA);

// Output all ifuncs.
if (!M->ifunc_empty()) Out << "\n";
for (const GlobalIFunc &GI : M->ifuncs())
  printIndirectSymbol(&GI);

// Output all of the functions.
for (const Function &F : *M) {
  Out << '\n';
  printFunction(&F);
}

// Output global use-lists.
printUseLists(nullptr);

// Output all attribute groups.
if (!Machine.as_empty()) {
  Out << '\n';
  writeAllAttributeGroups();
}

// Output named metadata.
if (!M->named_metadata_empty()) Out << '\n';

for (const NamedMDNode &Node : M->named_metadata())
  printNamedMDNode(&Node);

// Output metadata.
if (!Machine.mdn_empty()) {
  Out << '\n';
  writeAllMDNodes();
}
2889}

2891void AssemblyWriter::printModuleSummaryIndex() {
assert(TheIndex)((void)0);
int NumSlots = Machine.initializeIndexIfNeeded();

Out << "\n";

// Print module path entries. To print in order, add paths to a vector
// indexed by module slot.
std::vector<std::pair<std::string, ModuleHash>> moduleVec;
std::string RegularLTOModuleName =
    ModuleSummaryIndex::getRegularLTOModuleName();
moduleVec.resize(TheIndex->modulePaths().size());
for (auto &ModPath : TheIndex->modulePaths())
  moduleVec[Machine.getModulePathSlot(ModPath.first())] = std::make_pair(
      // A module id of -1 is a special entry for a regular LTO module created
      // during the thin link.
      ModPath.second.first == -1u ? RegularLTOModuleName
                                  : (std::string)std::string(ModPath.first()),
      ModPath.second.second);

unsigned i = 0;
for (auto &ModPair : moduleVec) {
  Out << "^" << i++ << " = module: (";
  Out << "path: \"";
  printEscapedString(ModPair.first, Out);
  Out << "\", hash: (";
  FieldSeparator FS;
  for (auto Hash : ModPair.second)
    Out << FS << Hash;
  Out << "))\n";
}

// FIXME: Change AliasSummary to hold a ValueInfo instead of summary pointer
// for aliasee (then update BitcodeWriter.cpp and remove get/setAliaseeGUID).
for (auto &GlobalList : *TheIndex) {
  auto GUID = GlobalList.first;
  for (auto &Summary : GlobalList.second.SummaryList)
    SummaryToGUIDMap[Summary.get()] = GUID;
}

// Print the global value summary entries.
for (auto &GlobalList : *TheIndex) {
  auto GUID = GlobalList.first;
  auto VI = TheIndex->getValueInfo(GlobalList);
  printSummaryInfo(Machine.getGUIDSlot(GUID), VI);
}

// Print the TypeIdMap entries.
for (const auto &TID : TheIndex->typeIds()) {
  Out << "^" << Machine.getTypeIdSlot(TID.second.first)
      << " = typeid: (name: \"" << TID.second.first << "\"";
  printTypeIdSummary(TID.second.second);
  Out << ") ; guid = " << TID.first << "\n";
}

// Print the TypeIdCompatibleVtableMap entries.
for (auto &TId : TheIndex->typeIdCompatibleVtableMap()) {
  auto GUID = GlobalValue::getGUID(TId.first);
  Out << "^" << Machine.getGUIDSlot(GUID)
      << " = typeidCompatibleVTable: (name: \"" << TId.first << "\"";
  printTypeIdCompatibleVtableSummary(TId.second);
  Out << ") ; guid = " << GUID << "\n";
}

// Don't emit flags when it's not really needed (value is zero by default).
if (TheIndex->getFlags()) {
  Out << "^" << NumSlots << " = flags: " << TheIndex->getFlags() << "\n";
  ++NumSlots;
}

Out << "^" << NumSlots << " = blockcount: " << TheIndex->getBlockCount()
    << "\n";
2963}

2965static const char *
2966getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K) {
switch (K) {
case WholeProgramDevirtResolution::Indir:
  return "indir";
case WholeProgramDevirtResolution::SingleImpl:
  return "singleImpl";
case WholeProgramDevirtResolution::BranchFunnel:
  return "branchFunnel";
}
llvm_unreachable("invalid WholeProgramDevirtResolution kind")__builtin_unreachable();
2976}

2978static const char *getWholeProgDevirtResByArgKindName(
  WholeProgramDevirtResolution::ByArg::Kind K) {
switch (K) {
case WholeProgramDevirtResolution::ByArg::Indir:
  return "indir";
case WholeProgramDevirtResolution::ByArg::UniformRetVal:
  return "uniformRetVal";
case WholeProgramDevirtResolution::ByArg::UniqueRetVal:
  return "uniqueRetVal";
case WholeProgramDevirtResolution::ByArg::VirtualConstProp:
  return "virtualConstProp";
}
llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind")__builtin_unreachable();
2991}

2993static const char *getTTResKindName(TypeTestResolution::Kind K) {
switch (K) {
case TypeTestResolution::Unknown:
  return "unknown";
case TypeTestResolution::Unsat:
  return "unsat";
case TypeTestResolution::ByteArray:
  return "byteArray";
case TypeTestResolution::Inline:
  return "inline";
case TypeTestResolution::Single:
  return "single";
case TypeTestResolution::AllOnes:
  return "allOnes";
}
llvm_unreachable("invalid TypeTestResolution kind")__builtin_unreachable();
3009}

3011void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {
Out << "typeTestRes: (kind: " << getTTResKindName(TTRes.TheKind)
    << ", sizeM1BitWidth: " << TTRes.SizeM1BitWidth;

// The following fields are only used if the target does not support the use
// of absolute symbols to store constants. Print only if non-zero.
if (TTRes.AlignLog2)
  Out << ", alignLog2: " << TTRes.AlignLog2;
if (TTRes.SizeM1)
  Out << ", sizeM1: " << TTRes.SizeM1;
if (TTRes.BitMask)
  // BitMask is uint8_t which causes it to print the corresponding char.
  Out << ", bitMask: " << (unsigned)TTRes.BitMask;
if (TTRes.InlineBits)
  Out << ", inlineBits: " << TTRes.InlineBits;

Out << ")";
3028}

3030void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {
Out << ", summary: (";
printTypeTestResolution(TIS.TTRes);
if (!TIS.WPDRes.empty()) {
  Out << ", wpdResolutions: (";
  FieldSeparator FS;
  for (auto &WPDRes : TIS.WPDRes) {
    Out << FS;
    Out << "(offset: " << WPDRes.first << ", ";
    printWPDRes(WPDRes.second);
    Out << ")";
  }
  Out << ")";
}
Out << ")";
3045}

3047void AssemblyWriter::printTypeIdCompatibleVtableSummary(
  const TypeIdCompatibleVtableInfo &TI) {
Out << ", summary: (";
FieldSeparator FS;
for (auto &P : TI) {
  Out << FS;
  Out << "(offset: " << P.AddressPointOffset << ", ";
  Out << "^" << Machine.getGUIDSlot(P.VTableVI.getGUID());
  Out << ")";
}
Out << ")";
3058}

3060void AssemblyWriter::printArgs(const std::vector<uint64_t> &Args) {
Out << "args: (";
FieldSeparator FS;
for (auto arg : Args) {
  Out << FS;
  Out << arg;
}
Out << ")";
3068}

3070void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
Out << "wpdRes: (kind: ";
Out << getWholeProgDevirtResKindName(WPDRes.TheKind);

if (WPDRes.TheKind == WholeProgramDevirtResolution::SingleImpl)
  Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";

if (!WPDRes.ResByArg.empty()) {
  Out << ", resByArg: (";
  FieldSeparator FS;
  for (auto &ResByArg : WPDRes.ResByArg) {
    Out << FS;
    printArgs(ResByArg.first);
    Out << ", byArg: (kind: ";
    Out << getWholeProgDevirtResByArgKindName(ResByArg.second.TheKind);
    if (ResByArg.second.TheKind ==
            WholeProgramDevirtResolution::ByArg::UniformRetVal ||
        ResByArg.second.TheKind ==
            WholeProgramDevirtResolution::ByArg::UniqueRetVal)
      Out << ", info: " << ResByArg.second.Info;

    // The following fields are only used if the target does not support the
    // use of absolute symbols to store constants. Print only if non-zero.
    if (ResByArg.second.Byte || ResByArg.second.Bit)
      Out << ", byte: " << ResByArg.second.Byte
          << ", bit: " << ResByArg.second.Bit;

    Out << ")";
  }
  Out << ")";
}
Out << ")";
3102}

3104static const char *getSummaryKindName(GlobalValueSummary::SummaryKind SK) {
switch (SK) {
case GlobalValueSummary::AliasKind:
  return "alias";
case GlobalValueSummary::FunctionKind:
  return "function";
case GlobalValueSummary::GlobalVarKind:
  return "variable";
}
llvm_unreachable("invalid summary kind")__builtin_unreachable();
3114}

3116void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
Out << ", aliasee: ";
// The indexes emitted for distributed backends may not include the
// aliasee summary (only if it is being imported directly). Handle
// that case by just emitting "null" as the aliasee.
if (AS->hasAliasee())
  Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
else
  Out << "null";
3125}

3127void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
auto VTableFuncs = GS->vTableFuncs();
Out << ", varFlags: (readonly: " << GS->VarFlags.MaybeReadOnly << ", "
    << "writeonly: " << GS->VarFlags.MaybeWriteOnly << ", "
    << "constant: " << GS->VarFlags.Constant;
if (!VTableFuncs.empty())
  Out << ", "
      << "vcall_visibility: " << GS->VarFlags.VCallVisibility;
Out << ")";

if (!VTableFuncs.empty()) {
  Out << ", vTableFuncs: (";
  FieldSeparator FS;
  for (auto &P : VTableFuncs) {
    Out << FS;
    Out << "(virtFunc: ^" << Machine.getGUIDSlot(P.FuncVI.getGUID())
        << ", offset: " << P.VTableOffset;
    Out << ")";
  }
  Out << ")";
}
3148}

3150static std::string getLinkageName(GlobalValue::LinkageTypes LT) {
switch (LT) {
case GlobalValue::ExternalLinkage:
  return "external";
case GlobalValue::PrivateLinkage:
  return "private";
case GlobalValue::InternalLinkage:
  return "internal";
case GlobalValue::LinkOnceAnyLinkage:
  return "linkonce";
case GlobalValue::LinkOnceODRLinkage:
  return "linkonce_odr";
case GlobalValue::WeakAnyLinkage:
  return "weak";
case GlobalValue::WeakODRLinkage:
  return "weak_odr";
case GlobalValue::CommonLinkage:
  return "common";
case GlobalValue::AppendingLinkage:
  return "appending";
case GlobalValue::ExternalWeakLinkage:
  return "extern_weak";
case GlobalValue::AvailableExternallyLinkage:
  return "available_externally";
}
llvm_unreachable("invalid linkage")__builtin_unreachable();
3176}

3178// When printing the linkage types in IR where the ExternalLinkage is
3179// not printed, and other linkage types are expected to be printed with
3180// a space after the name.
3181static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT) {
if (LT == GlobalValue::ExternalLinkage)
  return "";
return getLinkageName(LT) + " ";
3185}

3187static const char *getVisibilityName(GlobalValue::VisibilityTypes Vis) {
switch (Vis) {
case GlobalValue::DefaultVisibility:
  return "default";
case GlobalValue::HiddenVisibility:
  return "hidden";
case GlobalValue::ProtectedVisibility:
  return "protected";
}
llvm_unreachable("invalid visibility")__builtin_unreachable();
3197}

3199void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
Out << ", insts: " << FS->instCount();

FunctionSummary::FFlags FFlags = FS->fflags();
if (FFlags.ReadNone | FFlags.ReadOnly | FFlags.NoRecurse |
    FFlags.ReturnDoesNotAlias | FFlags.NoInline | FFlags.AlwaysInline) {
  Out << ", funcFlags: (";
  Out << "readNone: " << FFlags.ReadNone;
  Out << ", readOnly: " << FFlags.ReadOnly;
  Out << ", noRecurse: " << FFlags.NoRecurse;
  Out << ", returnDoesNotAlias: " << FFlags.ReturnDoesNotAlias;
  Out << ", noInline: " << FFlags.NoInline;
  Out << ", alwaysInline: " << FFlags.AlwaysInline;
  Out << ")";
}
if (!FS->calls().empty()) {
  Out << ", calls: (";
  FieldSeparator IFS;
  for (auto &Call : FS->calls()) {
    Out << IFS;
    Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());
    if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)
      Out << ", hotness: " << getHotnessName(Call.second.getHotness());
    else if (Call.second.RelBlockFreq)
      Out << ", relbf: " << Call.second.RelBlockFreq;
    Out << ")";
  }
  Out << ")";
}

if (const auto *TIdInfo = FS->getTypeIdInfo())
  printTypeIdInfo(*TIdInfo);

auto PrintRange = [&](const ConstantRange &Range) {
  Out << "[" << Range.getSignedMin() << ", " << Range.getSignedMax() << "]";
};

if (!FS->paramAccesses().empty()) {
  Out << ", params: (";
  FieldSeparator IFS;
  for (auto &PS : FS->paramAccesses()) {
    Out << IFS;
    Out << "(param: " << PS.ParamNo;
    Out << ", offset: ";
    PrintRange(PS.Use);
    if (!PS.Calls.empty()) {
      Out << ", calls: (";
      FieldSeparator IFS;
      for (auto &Call : PS.Calls) {
        Out << IFS;
        Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID());
        Out << ", param: " << Call.ParamNo;
        Out << ", offset: ";
        PrintRange(Call.Offsets);
        Out << ")";
      }
      Out << ")";
    }
    Out << ")";
  }
  Out << ")";
}
3261}

3263void AssemblyWriter::printTypeIdInfo(
  const FunctionSummary::TypeIdInfo &TIDInfo) {
Out << ", typeIdInfo: (";
FieldSeparator TIDFS;
if (!TIDInfo.TypeTests.empty()) {
  Out << TIDFS;
  Out << "typeTests: (";
  FieldSeparator FS;
  for (auto &GUID : TIDInfo.TypeTests) {
    auto TidIter = TheIndex->typeIds().equal_range(GUID);
    if (TidIter.first == TidIter.second) {
      Out << FS;
      Out << GUID;
      continue;
    }
    // Print all type id that correspond to this GUID.
    for (auto It = TidIter.first; It != TidIter.second; ++It) {
      Out << FS;
      auto Slot = Machine.getTypeIdSlot(It->second.first);
      assert(Slot != -1)((void)0);
      Out << "^" << Slot;
    }
  }
  Out << ")";
}
if (!TIDInfo.TypeTestAssumeVCalls.empty()) {
  Out << TIDFS;
  printNonConstVCalls(TIDInfo.TypeTestAssumeVCalls, "typeTestAssumeVCalls");
}
if (!TIDInfo.TypeCheckedLoadVCalls.empty()) {
  Out << TIDFS;
  printNonConstVCalls(TIDInfo.TypeCheckedLoadVCalls, "typeCheckedLoadVCalls");
}
if (!TIDInfo.TypeTestAssumeConstVCalls.empty()) {
  Out << TIDFS;
  printConstVCalls(TIDInfo.TypeTestAssumeConstVCalls,
                   "typeTestAssumeConstVCalls");
}
if (!TIDInfo.TypeCheckedLoadConstVCalls.empty()) {
  Out << TIDFS;
  printConstVCalls(TIDInfo.TypeCheckedLoadConstVCalls,
                   "typeCheckedLoadConstVCalls");
}
Out << ")";
3307}

3309void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {
auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);
if (TidIter.first == TidIter.second) {
  Out << "vFuncId: (";
  Out << "guid: " << VFId.GUID;
  Out << ", offset: " << VFId.Offset;
  Out << ")";
  return;
}
// Print all type id that correspond to this GUID.
FieldSeparator FS;
for (auto It = TidIter.first; It != TidIter.second; ++It) {
  Out << FS;
  Out << "vFuncId: (";
  auto Slot = Machine.getTypeIdSlot(It->second.first);
  assert(Slot != -1)((void)0);
  Out << "^" << Slot;
  Out << ", offset: " << VFId.Offset;
  Out << ")";
}
3329}

3331void AssemblyWriter::printNonConstVCalls(
  const std::vector<FunctionSummary::VFuncId> &VCallList, const char *Tag) {
Out << Tag << ": (";
FieldSeparator FS;
for (auto &VFuncId : VCallList) {
  Out << FS;
  printVFuncId(VFuncId);
}
Out << ")";
3340}

3342void AssemblyWriter::printConstVCalls(
  const std::vector<FunctionSummary::ConstVCall> &VCallList,
  const char *Tag) {
Out << Tag << ": (";
FieldSeparator FS;
for (auto &ConstVCall : VCallList) {
  Out << FS;
  Out << "(";
  printVFuncId(ConstVCall.VFunc);
  if (!ConstVCall.Args.empty()) {
    Out << ", ";
    printArgs(ConstVCall.Args);
  }
  Out << ")";
}
Out << ")";
3358}

3360void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
GlobalValueSummary::GVFlags GVFlags = Summary.flags();
GlobalValue::LinkageTypes LT = (GlobalValue::LinkageTypes)GVFlags.Linkage;
Out << getSummaryKindName(Summary.getSummaryKind()) << ": ";
Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())
    << ", flags: (";
Out << "linkage: " << getLinkageName(LT);
Out << ", visibility: "
    << getVisibilityName((GlobalValue::VisibilityTypes)GVFlags.Visibility);
Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
Out << ", live: " << GVFlags.Live;
Out << ", dsoLocal: " << GVFlags.DSOLocal;
Out << ", canAutoHide: " << GVFlags.CanAutoHide;
Out << ")";

if (Summary.getSummaryKind() == GlobalValueSummary::AliasKind)
  printAliasSummary(cast<AliasSummary>(&Summary));
else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
  printFunctionSummary(cast<FunctionSummary>(&Summary));
else
  printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));

auto RefList = Summary.refs();
if (!RefList.empty()) {
  Out << ", refs: (";
  FieldSeparator FS;
  for (auto &Ref : RefList) {
    Out << FS;
    if (Ref.isReadOnly())
      Out << "readonly ";
    else if (Ref.isWriteOnly())
      Out << "writeonly ";
    Out << "^" << Machine.getGUIDSlot(Ref.getGUID());
  }
  Out << ")";
}

Out << ")";
3398}

3400void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {
Out << "^" << Slot << " = gv: (";
if (!VI.name().empty())
  Out << "name: \"" << VI.name() << "\"";
else
  Out << "guid: " << VI.getGUID();
if (!VI.getSummaryList().empty()) {
  Out << ", summaries: (";
  FieldSeparator FS;
  for (auto &Summary : VI.getSummaryList()) {
    Out << FS;
    printSummary(*Summary);
  }
  Out << ")";
}
Out << ")";
if (!VI.name().empty())
  Out << " ; guid = " << VI.getGUID();
Out << "\n";
3419}

3421static void printMetadataIdentifier(StringRef Name,
                                  formatted_raw_ostream &Out) {
if (Name.empty()) {
  Out << "<empty name> ";
} else {
  if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
      Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
    Out << Name[0];
  else
    Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
  for (unsigned i = 1, e = Name.size(); i != e; ++i) {
    unsigned char C = Name[i];
    if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
        C == '.' || C == '_')
      Out << C;
    else
      Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
  }
}
3440}

3442void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
Out << '!';
printMetadataIdentifier(NMD->getName(), Out);
Out << " = !{";
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
  if (i)
    Out << ", ";

  // Write DIExpressions inline.
  // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
  MDNode *Op = NMD->getOperand(i);
  assert(!isa<DIArgList>(Op) &&((void)0)
         "DIArgLists should not appear in NamedMDNodes")((void)0);
  if (auto *Expr = dyn_cast<DIExpression>(Op)) {
    writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
    continue;
  }

  int Slot = Machine.getMetadataSlot(Op);
  if (Slot == -1)
    Out << "<badref>";
  else
    Out << '!' << Slot;
}
Out << "}\n";
3467}

3469static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
                          formatted_raw_ostream &Out) {
switch (Vis) {
case GlobalValue::DefaultVisibility: break;
case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
case GlobalValue::ProtectedVisibility: Out << "protected "; break;
}
3476}

3478static void PrintDSOLocation(const GlobalValue &GV,
                           formatted_raw_ostream &Out) {
if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
  Out << "dso_local ";
3482}

3484static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT,
                               formatted_raw_ostream &Out) {
switch (SCT) {
case GlobalValue::DefaultStorageClass: break;
case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
}
3491}

3493static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM,
                                formatted_raw_ostream &Out) {
switch (TLM) {
  case GlobalVariable::NotThreadLocal:
    break;
  case GlobalVariable::GeneralDynamicTLSModel:
    Out << "thread_local ";
    break;
  case GlobalVariable::LocalDynamicTLSModel:
    Out << "thread_local(localdynamic) ";
    break;
  case GlobalVariable::InitialExecTLSModel:
    Out << "thread_local(initialexec) ";
    break;
  case GlobalVariable::LocalExecTLSModel:
    Out << "thread_local(localexec) ";
    break;
}
3511}

3513static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA) {
switch (UA) {
case GlobalVariable::UnnamedAddr::None:
  return "";
case GlobalVariable::UnnamedAddr::Local:
  return "local_unnamed_addr";
case GlobalVariable::UnnamedAddr::Global:
  return "unnamed_addr";
}
llvm_unreachable("Unknown UnnamedAddr")__builtin_unreachable();
3523}

3525static void maybePrintComdat(formatted_raw_ostream &Out,
                           const GlobalObject &GO) {
const Comdat *C = GO.getComdat();
if (!C)
  return;

if (isa<GlobalVariable>(GO))
  Out << ',';
Out << " comdat";

if (GO.getName() == C->getName())
  return;

Out << '(';
PrintLLVMName(Out, C->getName(), ComdatPrefix);
Out << ')';
3541}

3543void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
if (GV->isMaterializable())
  Out << "; Materializable\n";

WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
Out << " = ";

if (!GV->hasInitializer() && GV->hasExternalLinkage())
  Out << "external ";

Out << getLinkageNameWithSpace(GV->getLinkage());
PrintDSOLocation(*GV, Out);
PrintVisibility(GV->getVisibility(), Out);
PrintDLLStorageClass(GV->getDLLStorageClass(), Out);
PrintThreadLocalModel(GV->getThreadLocalMode(), Out);
StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
if (!UA.empty())
    Out << UA << ' ';

if (unsigned AddressSpace = GV->getType()->getAddressSpace())
  Out << "addrspace(" << AddressSpace << ") ";
if (GV->isExternallyInitialized()) Out << "externally_initialized ";
Out << (GV->isConstant() ? "constant " : "global ");
TypePrinter.print(GV->getValueType(), Out);

if (GV->hasInitializer()) {
  Out << ' ';
  writeOperand(GV->getInitializer(), false);
}

if (GV->hasSection()) {
  Out << ", section \"";
  printEscapedString(GV->getSection(), Out);
  Out << '"';
}
if (GV->hasPartition()) {
  Out << ", partition \"";
  printEscapedString(GV->getPartition(), Out);
  Out << '"';
}

maybePrintComdat(Out, *GV);
if (GV->getAlignment())
  Out << ", align " << GV->getAlignment();

SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
GV->getAllMetadata(MDs);
printMetadataAttachments(MDs, ", ");

auto Attrs = GV->getAttributes();
if (Attrs.hasAttributes())
  Out << " #" << Machine.getAttributeGroupSlot(Attrs);

printInfoComment(*GV);
3597}

3599void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
if (GIS->isMaterializable())
  Out << "; Materializable\n";

WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
Out << " = ";

Out << getLinkageNameWithSpace(GIS->getLinkage());
PrintDSOLocation(*GIS, Out);
PrintVisibility(GIS->getVisibility(), Out);
PrintDLLStorageClass(GIS->getDLLStorageClass(), Out);
PrintThreadLocalModel(GIS->getThreadLocalMode(), Out);
StringRef UA = getUnnamedAddrEncoding(GIS->getUnnamedAddr());
if (!UA.empty())
    Out << UA << ' ';

if (isa<GlobalAlias>(GIS))
  Out << "alias ";
else if (isa<GlobalIFunc>(GIS))
  Out << "ifunc ";
else
  llvm_unreachable("Not an alias or ifunc!")__builtin_unreachable();

TypePrinter.print(GIS->getValueType(), Out);

Out << ", ";

const Constant *IS = GIS->getIndirectSymbol();

if (!IS) {
  TypePrinter.print(GIS->getType(), Out);
  Out << " <<NULL ALIASEE>>";
} else {
  writeOperand(IS, !isa<ConstantExpr>(IS));
}

if (GIS->hasPartition()) {
  Out << ", partition \"";
  printEscapedString(GIS->getPartition(), Out);
  Out << '"';
}

printInfoComment(*GIS);
Out << '\n';
3643}

3645void AssemblyWriter::printComdat(const Comdat *C) {
C->print(Out);
3647}

3649void AssemblyWriter::printTypeIdentities() {
if (TypePrinter.empty())
  return;

Out << '\n';

// Emit all numbered types.
auto &NumberedTypes = TypePrinter.getNumberedTypes();
for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
  Out << '%' << I << " = type ";

  // Make sure we print out at least one level of the type structure, so
  // that we do not get %2 = type %2
  TypePrinter.printStructBody(NumberedTypes[I], Out);
  Out << '\n';
}

auto &NamedTypes = TypePrinter.getNamedTypes();
for (unsigned I = 0, E = NamedTypes.size(); I != E; ++I) {
  PrintLLVMName(Out, NamedTypes[I]->getName(), LocalPrefix);
  Out << " = type ";

  // Make sure we print out at least one level of the type structure, so
  // that we do not get %FILE = type %FILE
  TypePrinter.printStructBody(NamedTypes[I], Out);
  Out << '\n';
}
3676}

3678/// printFunction - Print all aspects of a function.
3679void AssemblyWriter::printFunction(const Function *F) {
if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);

if (F->isMaterializable())
  Out << "; Materializable\n";

const AttributeList &Attrs = F->getAttributes();
if (Attrs.hasAttributes(AttributeList::FunctionIndex)) {
  AttributeSet AS = Attrs.getFnAttributes();
  std::string AttrStr;

  for (const Attribute &Attr : AS) {
    if (!Attr.isStringAttribute()) {
      if (!AttrStr.empty()) AttrStr += ' ';
      AttrStr += Attr.getAsString();
    }
  }

  if (!AttrStr.empty())
    Out << "; Function Attrs: " << AttrStr << '\n';
}

Machine.incorporateFunction(F);

if (F->isDeclaration()) {
  Out << "declare";
  SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
  F->getAllMetadata(MDs);
  printMetadataAttachments(MDs, " ");
  Out << ' ';
} else
  Out << "define ";

Out << getLinkageNameWithSpace(F->getLinkage());
PrintDSOLocation(*F, Out);
PrintVisibility(F->getVisibility(), Out);
PrintDLLStorageClass(F->getDLLStorageClass(), Out);

// Print the calling convention.
if (F->getCallingConv() != CallingConv::C) {
  PrintCallingConv(F->getCallingConv(), Out);
  Out << " ";
}

FunctionType *FT = F->getFunctionType();
if (Attrs.hasAttributes(AttributeList::ReturnIndex))
  Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
TypePrinter.print(F->getReturnType(), Out);
Out << ' ';
WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
Out << '(';

// Loop over the arguments, printing them...
if (F->isDeclaration() && !IsForDebug) {
  // We're only interested in the type here - don't print argument names.
  for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
    // Insert commas as we go... the first arg doesn't get a comma
    if (I)
      Out << ", ";
    // Output type...
    TypePrinter.print(FT->getParamType(I), Out);

    AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
    if (ArgAttrs.hasAttributes()) {
      Out << ' ';
      writeAttributeSet(ArgAttrs);
    }
  }
} else {
  // The arguments are meaningful here, print them in detail.
  for (const Argument &Arg : F->args()) {
    // Insert commas as we go... the first arg doesn't get a comma
    if (Arg.getArgNo() != 0)
      Out << ", ";
    printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
  }
}

// Finish printing arguments...
if (FT->isVarArg()) {
  if (FT->getNumParams()) Out << ", ";
  Out << "...";  // Output varargs portion of signature!
}
Out << ')';
StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
if (!UA.empty())
  Out << ' ' << UA;
// We print the function address space if it is non-zero or if we are writing
// a module with a non-zero program address space or if there is no valid
// Module* so that the file can be parsed without the datalayout string.
const Module *Mod = F->getParent();
if (F->getAddressSpace() != 0 || !Mod ||
    Mod->getDataLayout().getProgramAddressSpace() != 0)
  Out << " addrspace(" << F->getAddressSpace() << ")";
if (Attrs.hasAttributes(AttributeList::FunctionIndex))
  Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
if (F->hasSection()) {
  Out << " section \"";
  printEscapedString(F->getSection(), Out);
  Out << '"';
}
if (F->hasPartition()) {
  Out << " partition \"";
  printEscapedString(F->getPartition(), Out);
  Out << '"';
}
maybePrintComdat(Out, *F);
if (F->getAlignment())
  Out << " align " << F->getAlignment();
if (F->hasGC())
  Out << " gc \"" << F->getGC() << '"';
if (F->hasPrefixData()) {
  Out << " prefix ";
  writeOperand(F->getPrefixData(), true);
}
if (F->hasPrologueData()) {
  Out << " prologue ";
  writeOperand(F->getPrologueData(), true);
}
if (F->hasPersonalityFn()) {
  Out << " personality ";
  writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
}

if (F->isDeclaration()) {
  Out << '\n';
} else {
  SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
  F->getAllMetadata(MDs);
  printMetadataAttachments(MDs, " ");

  Out << " {";
  // Output all of the function's basic blocks.
  for (const BasicBlock &BB : *F)
    printBasicBlock(&BB);

  // Output the function's use-lists.
  printUseLists(F);

  Out << "}\n";
}

Machine.purgeFunction();
3822}

3824/// printArgument - This member is called for every argument that is passed into
3825/// the function.  Simply print it out
3826void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
// Output type...
TypePrinter.print(Arg->getType(), Out);

// Output parameter attributes list
if (Attrs.hasAttributes()) {
  Out << ' ';
  writeAttributeSet(Attrs);
}

// Output name, if available...
if (Arg->hasName()) {
  Out << ' ';
  PrintLLVMName(Out, Arg);
} else {
  int Slot = Machine.getLocalSlot(Arg);
  assert(Slot != -1 && "expect argument in function here")((void)0);
  Out << " %" << Slot;
}
3845}

3847/// printBasicBlock - This member is called for each basic block in a method.
3848void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
bool IsEntryBlock = BB->getParent() && BB->isEntryBlock();
if (BB->hasName()) {              // Print out the label if it exists...
  Out << "\n";
  PrintLLVMName(Out, BB->getName(), LabelPrefix);
  Out << ':';
} else if (!IsEntryBlock) {
  Out << "\n";
  int Slot = Machine.getLocalSlot(BB);
  if (Slot != -1)
    Out << Slot << ":";
  else
    Out << "<badref>:";
}

if (!IsEntryBlock) {
  // Output predecessors for the block.
  Out.PadToColumn(50);
  Out << ";";
  const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);

  if (PI == PE) {
    Out << " No predecessors!";
  } else {
    Out << " preds = ";
    writeOperand(*PI, false);
    for (++PI; PI != PE; ++PI) {
      Out << ", ";
      writeOperand(*PI, false);
    }
  }
}

Out << "\n";

if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);

// Output all of the instructions in the basic block...
for (const Instruction &I : *BB) {
  printInstructionLine(I);
}

if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
3891}

3893/// printInstructionLine - Print an instruction and a newline character.
3894void AssemblyWriter::printInstructionLine(const Instruction &I) {
printInstruction(I);
Out << '\n';
3897}

3899/// printGCRelocateComment - print comment after call to the gc.relocate
3900/// intrinsic indicating base and derived pointer names.
3901void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
Out << " ; (";
writeOperand(Relocate.getBasePtr(), false);
Out << ", ";
writeOperand(Relocate.getDerivedPtr(), false);
Out << ")";
3907}

3909/// printInfoComment - Print a little comment after the instruction indicating
3910/// which slot it occupies.
3911void AssemblyWriter::printInfoComment(const Value &V) {
if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
  printGCRelocateComment(*Relocate);

if (AnnotationWriter)
  AnnotationWriter->printInfoComment(V, Out);
3917}

3919static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
                                  raw_ostream &Out) {
// We print the address space of the call if it is non-zero.
unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
bool PrintAddrSpace = CallAddrSpace != 0;
if (!PrintAddrSpace) {
  const Module *Mod = getModuleFromVal(I);
  // We also print it if it is zero but not equal to the program address space
  // or if we can't find a valid Module* to make it possible to parse
  // the resulting file even without a datalayout string.
  if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
    PrintAddrSpace = true;
}
if (PrintAddrSpace)
  Out << " addrspace(" << CallAddrSpace << ")";
3934}

3936// This member is called for each Instruction in a function..
3937void AssemblyWriter::printInstruction(const Instruction &I) {
if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);

// Print out indentation for an instruction.
Out << "  ";

// Print out name if it exists...
if (I.hasName()) {
  PrintLLVMName(Out, &I);
  Out << " = ";
} else if (!I.getType()->isVoidTy()) {
  // Print out the def slot taken.
  int SlotNum = Machine.getLocalSlot(&I);
  if (SlotNum == -1)
    Out << "<badref> = ";
  else
    Out << '%' << SlotNum << " = ";
}

if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
  if (CI->isMustTailCall())
    Out << "musttail ";
  else if (CI->isTailCall())
    Out << "tail ";
  else if (CI->isNoTailCall())
    Out << "notail ";
}

// Print out the opcode...
Out << I.getOpcodeName();

// If this is an atomic load or store, print out the atomic marker.
if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isAtomic()) ||
    (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
  Out << " atomic";

if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
  Out << " weak";

// If this is a volatile operation, print out the volatile marker.
if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
    (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
    (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
    (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
  Out << " volatile";

// Print out optimization information.
WriteOptimizationInfo(Out, &I);

// Print out the compare instruction predicates
if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
  Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());

// Print out the atomicrmw operation
if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
  Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());

// Print out the type of the operands...
const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;

// Special case conditional branches to swizzle the condition out to the front
if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
  const BranchInst &BI(cast<BranchInst>(I));
  Out << ' ';
  writeOperand(BI.getCondition(), true);
  Out << ", ";
  writeOperand(BI.getSuccessor(0), true);
  Out << ", ";
  writeOperand(BI.getSuccessor(1), true);

} else if (isa<SwitchInst>(I)) {
  const SwitchInst& SI(cast<SwitchInst>(I));
  // Special case switch instruction to get formatting nice and correct.
  Out << ' ';
  writeOperand(SI.getCondition(), true);
  Out << ", ";
  writeOperand(SI.getDefaultDest(), true);
  Out << " [";
  for (auto Case : SI.cases()) {
    Out << "\n    ";
    writeOperand(Case.getCaseValue(), true);
    Out << ", ";
    writeOperand(Case.getCaseSuccessor(), true);
  }
  Out << "\n  ]";
} else if (isa<IndirectBrInst>(I)) {
  // Special case indirectbr instruction to get formatting nice and correct.
  Out << ' ';
  writeOperand(Operand, true);
  Out << ", [";

  for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
    if (i != 1)
      Out << ", ";
    writeOperand(I.getOperand(i), true);
  }
  Out << ']';
} else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
  Out << ' ';
  TypePrinter.print(I.getType(), Out);
  Out << ' ';

  for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
    if (op) Out << ", ";
    Out << "[ ";
    writeOperand(PN->getIncomingValue(op), false); Out << ", ";
    writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
  }
} else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
  Out << ' ';
  writeOperand(I.getOperand(0), true);
  for (unsigned i : EVI->indices())
    Out << ", " << i;
} else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
  Out << ' ';
  writeOperand(I.getOperand(0), true); Out << ", ";
  writeOperand(I.getOperand(1), true);
  for (unsigned i : IVI->indices())
    Out << ", " << i;
} else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
  Out << ' ';
  TypePrinter.print(I.getType(), Out);
  if (LPI->isCleanup() || LPI->getNumClauses() != 0)
    Out << '\n';

  if (LPI->isCleanup())
    Out << "          cleanup";

  for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
    if (i != 0 || LPI->isCleanup()) Out << "\n";
    if (LPI->isCatch(i))
      Out << "          catch ";
    else
      Out << "          filter ";

    writeOperand(LPI->getClause(i), true);
  }
} else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
  Out << " within ";
  writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
  Out << " [";
  unsigned Op = 0;
  for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
    if (Op > 0)
      Out << ", ";
    writeOperand(PadBB, /*PrintType=*/true);
    ++Op;
  }
  Out << "] unwind ";
  if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
    writeOperand(UnwindDest, /*PrintType=*/true);
  else
    Out << "to caller";
} else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
  Out << " within ";
  writeOperand(FPI->getParentPad(), /*PrintType=*/false);
  Out << " [";
  for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
       ++Op) {
    if (Op > 0)
      Out << ", ";
    writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
  }
  Out << ']';
} else if (isa<ReturnInst>(I) && !Operand) {
  Out << " void";
} else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
  Out << " from ";
  writeOperand(CRI->getOperand(0), /*PrintType=*/false);

  Out << " to ";
  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
} else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
  Out << " from ";
  writeOperand(CRI->getOperand(0), /*PrintType=*/false);

  Out << " unwind ";
  if (CRI->hasUnwindDest())
    writeOperand(CRI->getOperand(1), /*PrintType=*/true);
  else
    Out << "to caller";
} else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
  // Print the calling convention being used.
  if (CI->getCallingConv() != CallingConv::C) {
    Out << " ";
    PrintCallingConv(CI->getCallingConv(), Out);
  }

  Operand = CI->getCalledOperand();
  FunctionType *FTy = CI->getFunctionType();
  Type *RetTy = FTy->getReturnType();
  const AttributeList &PAL = CI->getAttributes();

  if (PAL.hasAttributes(AttributeList::ReturnIndex))
    Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

  // Only print addrspace(N) if necessary:
  maybePrintCallAddrSpace(Operand, &I, Out);

  // If possible, print out the short form of the call instruction.  We can
  // only do this if the first argument is a pointer to a nonvararg function,
  // and if the return type is not a pointer to a function.
  //
  Out << ' ';
  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
  Out << ' ';
  writeOperand(Operand, false);
  Out << '(';
  for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
    if (op > 0)
      Out << ", ";
    writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
  }

  // Emit an ellipsis if this is a musttail call in a vararg function.  This
  // is only to aid readability, musttail calls forward varargs by default.
  if (CI->isMustTailCall() && CI->getParent() &&
      CI->getParent()->getParent() &&
      CI->getParent()->getParent()->isVarArg())
    Out << ", ...";

  Out << ')';
  if (PAL.hasAttributes(AttributeList::FunctionIndex))
    Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());

  writeOperandBundles(CI);
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
  Operand = II->getCalledOperand();
  FunctionType *FTy = II->getFunctionType();
  Type *RetTy = FTy->getReturnType();
  const AttributeList &PAL = II->getAttributes();

  // Print the calling convention being used.
  if (II->getCallingConv() != CallingConv::C) {
    Out << " ";
    PrintCallingConv(II->getCallingConv(), Out);
  }

  if (PAL.hasAttributes(AttributeList::ReturnIndex))
    Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

  // Only print addrspace(N) if necessary:
  maybePrintCallAddrSpace(Operand, &I, Out);

  // If possible, print out the short form of the invoke instruction. We can
  // only do this if the first argument is a pointer to a nonvararg function,
  // and if the return type is not a pointer to a function.
  //
  Out << ' ';
  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
  Out << ' ';
  writeOperand(Operand, false);
  Out << '(';
  for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
    if (op)
      Out << ", ";
    writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
  }

  Out << ')';
  if (PAL.hasAttributes(AttributeList::FunctionIndex))
    Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());

  writeOperandBundles(II);

  Out << "\n          to ";
  writeOperand(II->getNormalDest(), true);
  Out << " unwind ";
  writeOperand(II->getUnwindDest(), true);
} else if (const CallBrInst *CBI = dyn_cast<CallBrInst>(&I)) {
  Operand = CBI->getCalledOperand();
  FunctionType *FTy = CBI->getFunctionType();
  Type *RetTy = FTy->getReturnType();
  const AttributeList &PAL = CBI->getAttributes();

  // Print the calling convention being used.
  if (CBI->getCallingConv() != CallingConv::C) {
    Out << " ";
    PrintCallingConv(CBI->getCallingConv(), Out);
  }

  if (PAL.hasAttributes(AttributeList::ReturnIndex))
    Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);

  // If possible, print out the short form of the callbr instruction. We can
  // only do this if the first argument is a pointer to a nonvararg function,
  // and if the return type is not a pointer to a function.
  //
  Out << ' ';
  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
  Out << ' ';
  writeOperand(Operand, false);
  Out << '(';
  for (unsigned op = 0, Eop = CBI->getNumArgOperands(); op < Eop; ++op) {
    if (op)
      Out << ", ";
    writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttributes(op));
  }

  Out << ')';
  if (PAL.hasAttributes(AttributeList::FunctionIndex))
    Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());

  writeOperandBundles(CBI);

  Out << "\n          to ";
  writeOperand(CBI->getDefaultDest(), true);
  Out << " [";
  for (unsigned i = 0, e = CBI->getNumIndirectDests(); i != e; ++i) {
    if (i != 0)
      Out << ", ";
    writeOperand(CBI->getIndirectDest(i), true);
  }
  Out << ']';
} else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
  Out << ' ';
  if (AI->isUsedWithInAlloca())
    Out << "inalloca ";
  if (AI->isSwiftError())
    Out << "swifterror ";
  TypePrinter.print(AI->getAllocatedType(), Out);

  // Explicitly write the array size if the code is broken, if it's an array
  // allocation, or if the type is not canonical for scalar allocations.  The
  // latter case prevents the type from mutating when round-tripping through
  // assembly.
  if (!AI->getArraySize() || AI->isArrayAllocation() ||
      !AI->getArraySize()->getType()->isIntegerTy(32)) {
    Out << ", ";
    writeOperand(AI->getArraySize(), true);
  }
  if (AI->getAlignment()) {
    Out << ", align " << AI->getAlignment();
  }

  unsigned AddrSpace = AI->getType()->getAddressSpace();
  if (AddrSpace != 0) {
    Out << ", addrspace(" << AddrSpace << ')';
  }
} else if (isa<CastInst>(I)) {
  if (Operand) {
    Out << ' ';
    writeOperand(Operand, true);   // Work with broken code
  }
  Out << " to ";
  TypePrinter.print(I.getType(), Out);
} else if (isa<VAArgInst>(I)) {
  if (Operand) {
    Out << ' ';
    writeOperand(Operand, true);   // Work with broken code
  }
  Out << ", ";
  TypePrinter.print(I.getType(), Out);
} else if (Operand) {   // Print the normal way.
  if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
    Out << ' ';
    TypePrinter.print(GEP->getSourceElementType(), Out);
    Out << ',';
  } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
    Out << ' ';
    TypePrinter.print(LI->getType(), Out);
    Out << ',';
  }

  // PrintAllTypes - Instructions who have operands of all the same type
  // omit the type from all but the first operand.  If the instruction has
  // different type operands (for example br), then they are all printed.
  bool PrintAllTypes = false;
  Type *TheType = Operand->getType();

  // Select, Store and ShuffleVector always print all types.
  if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
      || isa<ReturnInst>(I)) {
    PrintAllTypes = true;
  } else {
    for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
      Operand = I.getOperand(i);
      // note that Operand shouldn't be null, but the test helps make dump()
      // more tolerant of malformed IR
      if (Operand && Operand->getType() != TheType) {
        PrintAllTypes = true;    // We have differing types!  Print them all!
        break;
      }
    }
  }

  if (!PrintAllTypes) {
    Out << ' ';
    TypePrinter.print(TheType, Out);
  }

  Out << ' ';
  for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
    if (i) Out << ", ";
    writeOperand(I.getOperand(i), PrintAllTypes);
  }
}

// Print atomic ordering/alignment for memory operations
if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
  if (LI->isAtomic())
    writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
  if (LI->getAlignment())
    Out << ", align " << LI->getAlignment();
} else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
  if (SI->isAtomic())
    writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
  if (SI->getAlignment())
    Out << ", align " << SI->getAlignment();
} else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
  writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
                     CXI->getFailureOrdering(), CXI->getSyncScopeID());
  Out << ", align " << CXI->getAlign().value();
} else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
  writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
              RMWI->getSyncScopeID());
  Out << ", align " << RMWI->getAlign().value();
} else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
  writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
} else if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(&I)) {
  PrintShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());
}

// Print Metadata info.
SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
I.getAllMetadata(InstMD);
printMetadataAttachments(InstMD, ", ");

// Print a nice comment.
printInfoComment(I);
4367}

4369void AssemblyWriter::printMetadataAttachments(
  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
  StringRef Separator) {
if (MDs.empty())
  return;

if (MDNames.empty())
  MDs[0].second->getContext().getMDKindNames(MDNames);

for (const auto &I : MDs) {
  unsigned Kind = I.first;
  Out << Separator;
  if (Kind < MDNames.size()) {
    Out << "!";
    printMetadataIdentifier(MDNames[Kind], Out);
  } else
    Out << "!<unknown kind #" << Kind << ">";
  Out << ' ';
  WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
}
4389}

4391void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
Out << '!' << Slot << " = ";
printMDNodeBody(Node);
Out << "\n";
4395}

4397void AssemblyWriter::writeAllMDNodes() {
SmallVector<const MDNode *, 16> Nodes;
Nodes.resize(Machine.mdn_size());
for (auto &I : llvm::make_range(Machine.mdn_begin(), Machine.mdn_end()))
  Nodes[I.second] = cast<MDNode>(I.first);

for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
  writeMDNode(i, Nodes[i]);
}
4406}

4408void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
4410}

4412void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {
if (!Attr.isTypeAttribute()) {
  Out << Attr.getAsString(InAttrGroup);
  return;
}

Out << Attribute::getNameFromAttrKind(Attr.getKindAsEnum());
if (Type *Ty = Attr.getValueAsType()) {
  Out << '(';
  TypePrinter.print(Ty, Out);
  Out << ')';
}
4424}

4426void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,
                                     bool InAttrGroup) {
bool FirstAttr = true;
for (const auto &Attr : AttrSet) {
  if (!FirstAttr)
    Out << ' ';
  writeAttribute(Attr, InAttrGroup);
  FirstAttr = false;
}
4435}

4437void AssemblyWriter::writeAllAttributeGroups() {
std::vector<std::pair<AttributeSet, unsigned>> asVec;
asVec.resize(Machine.as_size());

for (auto &I : llvm::make_range(Machine.as_begin(), Machine.as_end()))
  asVec[I.second] = I;

for (const auto &I : asVec)
  Out << "attributes #" << I.second << " = { "
      << I.first.getAsString(true) << " }\n";
4447}

4449void AssemblyWriter::printUseListOrder(const Value *V,
                                     const std::vector<unsigned> &Shuffle) {
bool IsInFunction = Machine.getFunction();
if (IsInFunction)
  Out << "  ";

Out << "uselistorder";
if (const BasicBlock *BB = IsInFunction ? nullptr : dyn_cast<BasicBlock>(V)) {
  Out << "_bb ";
  writeOperand(BB->getParent(), false);
  Out << ", ";
  writeOperand(BB, false);
} else {
  Out << " ";
  writeOperand(V, true);
}
Out << ", { ";

assert(Shuffle.size() >= 2 && "Shuffle too small")((void)0);
Out << Shuffle[0];
for (unsigned I = 1, E = Shuffle.size(); I != E; ++I)
  Out << ", " << Shuffle[I];
Out << " }\n";
4472}

4474void AssemblyWriter::printUseLists(const Function *F) {
auto It = UseListOrders.find(F);
if (It == UseListOrders.end())
  return;

Out << "\n; uselistorder directives\n";
for (const auto &Pair : It->second)
  printUseListOrder(Pair.first, Pair.second);
4482}

4484//===----------------------------------------------------------------------===//
4485//                       External Interface declarations
4486//===----------------------------------------------------------------------===//

4488void Function::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
                   bool ShouldPreserveUseListOrder,
                   bool IsForDebug) const {
SlotTracker SlotTable(this->getParent());
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
                 IsForDebug,
                 ShouldPreserveUseListOrder);
W.printFunction(this);
4497}

4499void BasicBlock::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
                   bool ShouldPreserveUseListOrder,
                   bool IsForDebug) const {
SlotTracker SlotTable(this->getParent());
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, this->getModule(), AAW,
                 IsForDebug,
                 ShouldPreserveUseListOrder);
W.printBasicBlock(this);
4508}

4510void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW,
                 bool ShouldPreserveUseListOrder, bool IsForDebug) const {
SlotTracker SlotTable(this);
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
                 ShouldPreserveUseListOrder);
W.printModule(this);
4517}

4519void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
SlotTracker SlotTable(getParent());
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
W.printNamedMDNode(this);
4524}

4526void NamedMDNode::print(raw_ostream &ROS, ModuleSlotTracker &MST,
                      bool IsForDebug) const {
Optional<SlotTracker> LocalST;
SlotTracker *SlotTable;
if (auto *ST = MST.getMachine())
  SlotTable = ST;
else {
  LocalST.emplace(getParent());
  SlotTable = &*LocalST;
}

formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
W.printNamedMDNode(this);
4540}

4542void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
PrintLLVMName(ROS, getName(), ComdatPrefix);
ROS << " = comdat ";

switch (getSelectionKind()) {
case Comdat::Any:
  ROS << "any";
  break;
case Comdat::ExactMatch:
  ROS << "exactmatch";
  break;
case Comdat::Largest:
  ROS << "largest";
  break;
case Comdat::NoDeduplicate:
  ROS << "nodeduplicate";
  break;
case Comdat::SameSize:
  ROS << "samesize";
  break;
}

ROS << '\n';
4565}

4567void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
TypePrinting TP;
TP.print(const_cast<Type*>(this), OS);

if (NoDetails)
  return;

// If the type is a named struct type, print the body as well.
if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
  if (!STy->isLiteral()) {
    OS << " = type ";
    TP.printStructBody(STy, OS);
  }
4580}

4582static bool isReferencingMDNode(const Instruction &I) {
if (const auto *CI = dyn_cast<CallInst>(&I))
  if (Function *F = CI->getCalledFunction())
    if (F->isIntrinsic())
      for (auto &Op : I.operands())
        if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
          if (isa<MDNode>(V->getMetadata()))
            return true;
return false;
4591}

4593void Value::print(raw_ostream &ROS, bool IsForDebug) const {
bool ShouldInitializeAllMetadata = false;
if (auto *I1.1
'I' is null
1
'I' is null
 = dyn_cast<Instruction>(this))
1
Assuming the object is not a 'Instruction'→
2
←
Taking false branch→
  ShouldInitializeAllMetadata = isReferencingMDNode(*I);
else if (isa<Function>(this) || isa<MetadataAsValue>(this))
3
←
Assuming the object is not a 'Function'→
4
←
Assuming the object is not a 'MetadataAsValue'→
5
←
Taking false branch→
  ShouldInitializeAllMetadata = true;

ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
print(ROS, MST, IsForDebug);
6
←
Calling 'Value::print'→
4602}

4604void Value::print(raw_ostream &ROS, ModuleSlotTracker &MST,
                bool IsForDebug) const {
formatted_raw_ostream OS(ROS);
SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
SlotTracker &SlotTable =
    MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
7
←
'?' condition is true→
auto incorporateFunction = [&](const Function *F) {
  if (F)
    MST.incorporateFunction(*F);
};

if (const Instruction *I8.1
'I' is null
1
'I' is null
 = dyn_cast<Instruction>(this)) {
8
←
The object is not a 'Instruction'→
9
←
Taking false branch→
  incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
  AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
  W.printInstruction(*I);
} else if (const BasicBlock *BB10.1
'BB' is null
1
'BB' is null
 = dyn_cast<BasicBlock>(this)) {
10
←
Assuming the object is not a 'BasicBlock'→
11
←
Taking false branch→
  incorporateFunction(BB->getParent());
  AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
  W.printBasicBlock(BB);
} else if (const GlobalValue *GV12.1
'GV' is null
1
'GV' is null
 = dyn_cast<GlobalValue>(this)) {
12
←
Assuming the object is not a 'GlobalValue'→
13
←
Taking false branch→
  AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
  if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
    W.printGlobal(V);
  else if (const Function *F = dyn_cast<Function>(GV))
    W.printFunction(F);
  else
    W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
} else if (const MetadataAsValue *V14.1
'V' is non-null
1
'V' is non-null
 = dyn_cast<MetadataAsValue>(this)) {
14
←
Assuming the object is a 'MetadataAsValue'→
15
←
Taking true branch→
  V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
16
←
Calling 'Metadata::print'→
} else if (const Constant *C = dyn_cast<Constant>(this)) {
  TypePrinting TypePrinter;
  TypePrinter.print(C->getType(), OS);
  OS << ' ';
  WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
} else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
  this->printAsOperand(OS, /* PrintType */ true, MST);
} else {
  llvm_unreachable("Unknown value to print out!")__builtin_unreachable();
}
4643}

4645/// Print without a type, skipping the TypePrinting object.
4646///
4647/// \return \c true iff printing was successful.
4648static bool printWithoutType(const Value &V, raw_ostream &O,
                           SlotTracker *Machine, const Module *M) {
if (V.hasName() || isa<GlobalValue>(V) ||
    (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
  WriteAsOperandInternal(O, &V, nullptr, Machine, M);
  return true;
}
return false;
4656}

4658static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
                             ModuleSlotTracker &MST) {
TypePrinting TypePrinter(MST.getModule());
if (PrintType) {
  TypePrinter.print(V.getType(), O);
  O << ' ';
}

WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
                       MST.getModule());
4668}

4670void Value::printAsOperand(raw_ostream &O, bool PrintType,
                         const Module *M) const {
if (!M)
  M = getModuleFromVal(this);

if (!PrintType)
  if (printWithoutType(*this, O, nullptr, M))
    return;

SlotTracker Machine(
    M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
ModuleSlotTracker MST(Machine, M);
printAsOperandImpl(*this, O, PrintType, MST);
4683}

4685void Value::printAsOperand(raw_ostream &O, bool PrintType,
                         ModuleSlotTracker &MST) const {
if (!PrintType)
  if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
    return;

printAsOperandImpl(*this, O, PrintType, MST);
4692}

4694static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
                            ModuleSlotTracker &MST, const Module *M,
                            bool OnlyAsOperand) {
formatted_raw_ostream OS(ROS);

TypePrinting TypePrinter(M);

WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
                       /* FromValue */ true);

auto *N = dyn_cast<MDNode>(&MD);
18
←
Assuming the object is a 'MDNode'→
if (OnlyAsOperand18.1
'OnlyAsOperand' is false
1
'OnlyAsOperand' is false
 || !N18.2
'N' is non-null
2
'N' is non-null
 || isa<DIExpression>(MD) || isa<DIArgList>(MD))
19
←
Assuming 'MD' is not a 'DIExpression'→
20
←
Assuming 'MD' is not a 'DIArgList'→
21
←
Taking false branch→
  return;

OS << " = ";
WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
22
←
Calling 'WriteMDNodeBodyInternal'→
4710}

4712void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
ModuleSlotTracker MST(M, isa<MDNode>(this));
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4715}

4717void Metadata::printAsOperand(raw_ostream &OS, ModuleSlotTracker &MST,
                            const Module *M) const {
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4720}

4722void Metadata::print(raw_ostream &OS, const Module *M,
                   bool /*IsForDebug*/) const {
ModuleSlotTracker MST(M, isa<MDNode>(this));
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
4726}

4728void Metadata::print(raw_ostream &OS, ModuleSlotTracker &MST,
                   const Module *M, bool /*IsForDebug*/) const {
printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
17
←
Calling 'printMetadataImpl'→
4731}

4733void ModuleSummaryIndex::print(raw_ostream &ROS, bool IsForDebug) const {
SlotTracker SlotTable(this);
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, this, IsForDebug);
W.printModuleSummaryIndex();
4738}

4740void ModuleSlotTracker::collectMDNodes(MachineMDNodeListType &L, unsigned LB,
                                     unsigned UB) const {
SlotTracker *ST = MachineStorage.get();
if (!ST)
  return;

for (auto &I : llvm::make_range(ST->mdn_begin(), ST->mdn_end()))
  if (I.second >= LB && I.second < UB)
    L.push_back(std::make_pair(I.second, I.first));
4749}

4751#if !defined(NDEBUG1) || defined(LLVM_ENABLE_DUMP)
4752// Value::dump - allow easy printing of Values from the debugger.
4753LLVM_DUMP_METHOD__attribute__((noinline))
4754void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }

4756// Type::dump - allow easy printing of Types from the debugger.
4757LLVM_DUMP_METHOD__attribute__((noinline))
4758void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }

4760// Module::dump() - Allow printing of Modules from the debugger.
4761LLVM_DUMP_METHOD__attribute__((noinline))
4762void Module::dump() const {
print(dbgs(), nullptr,
      /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
4765}

4767// Allow printing of Comdats from the debugger.
4768LLVM_DUMP_METHOD__attribute__((noinline))
4769void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }

4771// NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
4772LLVM_DUMP_METHOD__attribute__((noinline))
4773void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }

4775LLVM_DUMP_METHOD__attribute__((noinline))
4776void Metadata::dump() const { dump(nullptr); }

4778LLVM_DUMP_METHOD__attribute__((noinline))
4779void Metadata::dump(const Module *M) const {
print(dbgs(), M, /*IsForDebug=*/true);
dbgs() << '\n';
4782}

4784// Allow printing of ModuleSummaryIndex from the debugger.
4785LLVM_DUMP_METHOD__attribute__((noinline))
4786void ModuleSummaryIndex::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4787#endif

←

/usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR/Metadata.def

1//===- llvm/IR/Metadata.def - Metadata definitions --------------*- C++ -*-===//
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// Macros for running through all types of metadata.
10//
11//===----------------------------------------------------------------------===//
12 
13#if !(defined HANDLE_METADATA || defined HANDLE_METADATA_LEAF ||               \
14      defined HANDLE_METADATA_BRANCH || defined HANDLE_MDNODE_LEAF ||          \
15      defined HANDLE_MDNODE_LEAF_UNIQUABLE || defined HANDLE_MDNODE_BRANCH ||  \
16      defined HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE ||                      \
17      defined HANDLE_SPECIALIZED_MDNODE_LEAF ||                                \
18      defined HANDLE_SPECIALIZED_MDNODE_BRANCH)
19#error "Missing macro definition of HANDLE_METADATA*"
20#endif
21 
22// Handler for all types of metadata.
23#ifndef HANDLE_METADATA
24#define HANDLE_METADATA(CLASS)
25#endif
26 
27// Handler for leaf nodes in the class hierarchy.
28#ifndef HANDLE_METADATA_LEAF
29#define HANDLE_METADATA_LEAF(CLASS) HANDLE_METADATA(CLASS)
30#endif
31 
32// Handler for non-leaf nodes in the class hierarchy.
33#ifndef HANDLE_METADATA_BRANCH
34#define HANDLE_METADATA_BRANCH(CLASS) HANDLE_METADATA(CLASS)
35#endif
36 
37// Handler for specialized and uniquable leaf nodes under MDNode.  Defers to
38// HANDLE_MDNODE_LEAF_UNIQUABLE if it's defined, otherwise to
39// HANDLE_SPECIALIZED_MDNODE_LEAF.
40#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
41#ifdef HANDLE_MDNODE_LEAF_UNIQUABLE
42#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(CLASS)                        \
43  HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
44#else
45#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(CLASS)                        \
46  HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)
47#endif
48#endif
49 
50// Handler for leaf nodes under MDNode.
51#ifndef HANDLE_MDNODE_LEAF_UNIQUABLE
52#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) HANDLE_MDNODE_LEAF(CLASS)
53#endif
54 
55// Handler for leaf nodes under MDNode.
56#ifndef HANDLE_MDNODE_LEAF
57#define HANDLE_MDNODE_LEAF(CLASS) HANDLE_METADATA_LEAF(CLASS)
58#endif
59 
60// Handler for non-leaf nodes under MDNode.
61#ifndef HANDLE_MDNODE_BRANCH
62#define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_METADATA_BRANCH(CLASS)
63#endif
64 
65// Handler for specialized leaf nodes under MDNode.
66#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF
67#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) HANDLE_MDNODE_LEAF(CLASS)
68#endif
69 
70// Handler for specialized non-leaf nodes under MDNode.
71#ifndef HANDLE_SPECIALIZED_MDNODE_BRANCH
72#define HANDLE_SPECIALIZED_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_BRANCH(CLASS)
73#endif
74 
75HANDLE_METADATA_LEAF(MDString)
76HANDLE_METADATA_BRANCH(ValueAsMetadata)
77HANDLE_METADATA_LEAF(ConstantAsMetadata)
78HANDLE_METADATA_LEAF(LocalAsMetadata)
79HANDLE_METADATA_LEAF(DistinctMDOperandPlaceholder)
80HANDLE_MDNODE_BRANCH(MDNode)
81HANDLE_MDNODE_LEAF_UNIQUABLE(MDTuple)
82HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocation)
83HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIExpression)
84HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariableExpression)
85HANDLE_SPECIALIZED_MDNODE_BRANCH(DINode)
86HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(GenericDINode)
87HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubrange)
88HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIEnumerator)
89HANDLE_SPECIALIZED_MDNODE_BRANCH(DIScope)
90HANDLE_SPECIALIZED_MDNODE_BRANCH(DIType)
91HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIBasicType)
92HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIDerivedType)
93HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
94HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubroutineType)
95HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFile)
96HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
97HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
98HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubprogram)
99HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
100HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlock)
101HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlockFile)
102HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DINamespace)
103HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)
104HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
105HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
106HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)
107HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
108HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
109HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
110HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILabel)
111HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
112HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
113HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
114HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
115HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
116HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
117HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIArgList)
118HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
119HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
26
←
'Node' is a 'DIGenericSubrange'→
27
←
Calling 'writeDIGenericSubrange'→
120 
121#undef HANDLE_METADATA
122#undef HANDLE_METADATA_LEAF
123#undef HANDLE_METADATA_BRANCH
124#undef HANDLE_MDNODE_LEAF
125#undef HANDLE_MDNODE_LEAF_UNIQUABLE
126#undef HANDLE_MDNODE_BRANCH
127#undef HANDLE_SPECIALIZED_MDNODE_LEAF
128#undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
129#undef HANDLE_SPECIALIZED_MDNODE_BRANCH