/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/DebugInfoMetadata.cpp

Bug Summary

File:	llvm/lib/IR/DebugInfoMetadata.cpp
Warning:	line 1487, column 28 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DebugInfoMetadata.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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/DebugInfoMetadata.cpp
1//===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===//
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 file implements the debug info Metadata classes.
10//
11//===----------------------------------------------------------------------===//

13#include "llvm/IR/DebugInfoMetadata.h"
14#include "LLVMContextImpl.h"
15#include "MetadataImpl.h"
16#include "llvm/ADT/SmallSet.h"
17#include "llvm/ADT/StringSwitch.h"
18#include "llvm/IR/DIBuilder.h"
19#include "llvm/IR/Function.h"
20#include "llvm/IR/Instructions.h"

22#include <numeric>

24using namespace llvm;

26namespace llvm {
27// Use FS-AFDO discriminator.
28cl::opt<bool> EnableFSDiscriminator(
  "enable-fs-discriminator", cl::Hidden, cl::init(false),
  cl::desc("Enable adding flow sensitive discriminators"));
31} // namespace llvm

33const DIExpression::FragmentInfo DebugVariable::DefaultFragment = {
  std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};

36DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
                     unsigned Column, ArrayRef<Metadata *> MDs,
                     bool ImplicitCode)
  : MDNode(C, DILocationKind, Storage, MDs) {
assert((MDs.size() == 1 || MDs.size() == 2) &&(static_cast<void> (0))
       "Expected a scope and optional inlined-at")(static_cast<void> (0));

// Set line and column.
assert(Column < (1u << 16) && "Expected 16-bit column")(static_cast<void> (0));

SubclassData32 = Line;
SubclassData16 = Column;

setImplicitCode(ImplicitCode);
50}

52static void adjustColumn(unsigned &Column) {
// Set to unknown on overflow.  We only have 16 bits to play with here.
if (Column >= (1u << 16))
  Column = 0;
56}

58DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
                              unsigned Column, Metadata *Scope,
                              Metadata *InlinedAt, bool ImplicitCode,
                              StorageType Storage, bool ShouldCreate) {
// Fixup column.
adjustColumn(Column);

if (Storage == Uniqued) {
  if (auto *N = getUniqued(Context.pImpl->DILocations,
                           DILocationInfo::KeyTy(Line, Column, Scope,
                                                 InlinedAt, ImplicitCode)))
    return N;
  if (!ShouldCreate)
    return nullptr;
} else {
  assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast<void> (0));
}

SmallVector<Metadata *, 2> Ops;
Ops.push_back(Scope);
if (InlinedAt)
  Ops.push_back(InlinedAt);
return storeImpl(new (Ops.size()) DILocation(Context, Storage, Line, Column,
                                             Ops, ImplicitCode),
                 Storage, Context.pImpl->DILocations);
83}

85const
86DILocation *DILocation::getMergedLocations(ArrayRef<const DILocation *> Locs) {
if (Locs.empty())
  return nullptr;
if (Locs.size() == 1)
  return Locs[0];
auto *Merged = Locs[0];
for (const DILocation *L : llvm::drop_begin(Locs)) {
  Merged = getMergedLocation(Merged, L);
  if (Merged == nullptr)
    break;
}
return Merged;
98}

100const DILocation *DILocation::getMergedLocation(const DILocation *LocA,
                                              const DILocation *LocB) {
if (!LocA || !LocB)
  return nullptr;

if (LocA == LocB)
  return LocA;

SmallPtrSet<DILocation *, 5> InlinedLocationsA;
for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt())
  InlinedLocationsA.insert(L);
SmallSet<std::pair<DIScope *, DILocation *>, 5> Locations;
DIScope *S = LocA->getScope();
DILocation *L = LocA->getInlinedAt();
while (S) {
  Locations.insert(std::make_pair(S, L));
  S = S->getScope();
  if (!S && L) {
    S = L->getScope();
    L = L->getInlinedAt();
  }
}
const DILocation *Result = LocB;
S = LocB->getScope();
L = LocB->getInlinedAt();
while (S) {
  if (Locations.count(std::make_pair(S, L)))
    break;
  S = S->getScope();
  if (!S && L) {
    S = L->getScope();
    L = L->getInlinedAt();
  }
}

// If the two locations are irreconsilable, just pick one. This is misleading,
// but on the other hand, it's a "line 0" location.
if (!S || !isa<DILocalScope>(S))
  S = LocA->getScope();
return DILocation::get(Result->getContext(), 0, 0, S, L);
140}

142Optional<unsigned> DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) {
std::array<unsigned, 3> Components = {BD, DF, CI};
uint64_t RemainingWork = 0U;
// We use RemainingWork to figure out if we have no remaining components to
// encode. For example: if BD != 0 but DF == 0 && CI == 0, we don't need to
// encode anything for the latter 2.
// Since any of the input components is at most 32 bits, their sum will be
// less than 34 bits, and thus RemainingWork won't overflow.
RemainingWork = std::accumulate(Components.begin(), Components.end(), RemainingWork);

int I = 0;
unsigned Ret = 0;
unsigned NextBitInsertionIndex = 0;
while (RemainingWork > 0) {
  unsigned C = Components[I++];
  RemainingWork -= C;
  unsigned EC = encodeComponent(C);
  Ret |= (EC << NextBitInsertionIndex);
  NextBitInsertionIndex += encodingBits(C);
}

// Encoding may be unsuccessful because of overflow. We determine success by
// checking equivalence of components before & after encoding. Alternatively,
// we could determine Success during encoding, but the current alternative is
// simpler.
unsigned TBD, TDF, TCI = 0;
decodeDiscriminator(Ret, TBD, TDF, TCI);
if (TBD == BD && TDF == DF && TCI == CI)
  return Ret;
return None;
172}

174void DILocation::decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF,
                                   unsigned &CI) {
BD = getUnsignedFromPrefixEncoding(D);
DF = getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator(D));
CI = getUnsignedFromPrefixEncoding(
    getNextComponentInDiscriminator(getNextComponentInDiscriminator(D)));
180}


183DINode::DIFlags DINode::getFlag(StringRef Flag) {
return StringSwitch<DIFlags>(Flag)
185#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
186#include "llvm/IR/DebugInfoFlags.def"
    .Default(DINode::FlagZero);
188}

190StringRef DINode::getFlagString(DIFlags Flag) {
switch (Flag) {
192#define HANDLE_DI_FLAG(ID, NAME)                                               \
case Flag##NAME:                                                             \
  return "DIFlag" #NAME;
195#include "llvm/IR/DebugInfoFlags.def"
}
return "";
198}

200DINode::DIFlags DINode::splitFlags(DIFlags Flags,
                                 SmallVectorImpl<DIFlags> &SplitFlags) {
// Flags that are packed together need to be specially handled, so
// that, for example, we emit "DIFlagPublic" and not
// "DIFlagPrivate | DIFlagProtected".
if (DIFlags A = Flags & FlagAccessibility) {
  if (A == FlagPrivate)
    SplitFlags.push_back(FlagPrivate);
  else if (A == FlagProtected)
    SplitFlags.push_back(FlagProtected);
  else
    SplitFlags.push_back(FlagPublic);
  Flags &= ~A;
}
if (DIFlags R = Flags & FlagPtrToMemberRep) {
  if (R == FlagSingleInheritance)
    SplitFlags.push_back(FlagSingleInheritance);
  else if (R == FlagMultipleInheritance)
    SplitFlags.push_back(FlagMultipleInheritance);
  else
    SplitFlags.push_back(FlagVirtualInheritance);
  Flags &= ~R;
}
if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
  Flags &= ~FlagIndirectVirtualBase;
  SplitFlags.push_back(FlagIndirectVirtualBase);
}

228#define HANDLE_DI_FLAG(ID, NAME)                                               \
if (DIFlags Bit = Flags & Flag##NAME) {                                      \
  SplitFlags.push_back(Bit);                                                 \
  Flags &= ~Bit;                                                             \
}
233#include "llvm/IR/DebugInfoFlags.def"
return Flags;
235}

237DIScope *DIScope::getScope() const {
if (auto *T = dyn_cast<DIType>(this))
  return T->getScope();

if (auto *SP = dyn_cast<DISubprogram>(this))
  return SP->getScope();

if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
  return LB->getScope();

if (auto *NS = dyn_cast<DINamespace>(this))
  return NS->getScope();

if (auto *CB = dyn_cast<DICommonBlock>(this))
  return CB->getScope();

if (auto *M = dyn_cast<DIModule>(this))
  return M->getScope();

assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&(static_cast<void> (0))
       "Unhandled type of scope.")(static_cast<void> (0));
return nullptr;
259}

261StringRef DIScope::getName() const {
if (auto *T = dyn_cast<DIType>(this))
  return T->getName();
if (auto *SP = dyn_cast<DISubprogram>(this))
  return SP->getName();
if (auto *NS = dyn_cast<DINamespace>(this))
  return NS->getName();
if (auto *CB = dyn_cast<DICommonBlock>(this))
  return CB->getName();
if (auto *M = dyn_cast<DIModule>(this))
  return M->getName();
assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||(static_cast<void> (0))
        isa<DICompileUnit>(this)) &&(static_cast<void> (0))
       "Unhandled type of scope.")(static_cast<void> (0));
return "";
276}

278#ifndef NDEBUG1
279static bool isCanonical(const MDString *S) {
return !S || !S->getString().empty();
281}
282#endif

284GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
                                    MDString *Header,
                                    ArrayRef<Metadata *> DwarfOps,
                                    StorageType Storage, bool ShouldCreate) {
unsigned Hash = 0;
if (Storage == Uniqued) {
  GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
  if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
    return N;
  if (!ShouldCreate)
    return nullptr;
  Hash = Key.getHash();
} else {
  assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast<void> (0));
}

// Use a nullptr for empty headers.
assert(isCanonical(Header) && "Expected canonical MDString")(static_cast<void> (0));
Metadata *PreOps[] = {Header};
return storeImpl(new (DwarfOps.size() + 1) GenericDINode(
                     Context, Storage, Hash, Tag, PreOps, DwarfOps),
                 Storage, Context.pImpl->GenericDINodes);
306}

308void GenericDINode::recalculateHash() {
setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
310}

312#define UNWRAP_ARGS_IMPL(...)... __VA_ARGS__
313#define UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS UNWRAP_ARGS_IMPL ARGS
314#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS)do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->CLASSs, CLASSInfo::KeyTy(UNWRAP_ARGS_IMPL ARGS))) return
 N; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)                                     \
do {                                                                         \
  if (Storage == Uniqued) {                                                  \
    if (auto *N = getUniqued(Context.pImpl->CLASS##s,                        \
                             CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS)))         \
      return N;                                                              \
    if (!ShouldCreate)                                                       \
      return nullptr;                                                        \
  } else {                                                                   \
    assert(ShouldCreate &&                                                   \(static_cast<void> (0))
           "Expected non-uniqued nodes to always be created")(static_cast<void> (0));               \
  }                                                                          \
} while (false)
327#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage
, UNWRAP_ARGS_IMPL ARGS, OPS), Storage, Context.pImpl->CLASSs
)                                 \
return storeImpl(new (array_lengthof(OPS))                                   \
                     CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS),        \
                 Storage, Context.pImpl->CLASS##s)
331#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS)return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS_IMPL
 ARGS), Storage, Context.pImpl->CLASSs)                               \
return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS),        \
                 Storage, Context.pImpl->CLASS##s)
334#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage
, OPS), Storage, Context.pImpl->CLASSs)                   \
return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS),     \
                 Storage, Context.pImpl->CLASS##s)
337#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS)return storeImpl(new (NUM_OPS) CLASS(Context, Storage, UNWRAP_ARGS_IMPL
 ARGS, OPS), Storage, Context.pImpl->CLASSs)                      \
return storeImpl(new (NUM_OPS)                                               \
                     CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS),        \
                 Storage, Context.pImpl->CLASS##s)

342DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
                              StorageType Storage, bool ShouldCreate) {
auto *CountNode = ConstantAsMetadata::get(
    ConstantInt::getSigned(Type::getInt64Ty(Context), Count));
auto *LB = ConstantAsMetadata::get(
    ConstantInt::getSigned(Type::getInt64Ty(Context), Lo));
return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage,
               ShouldCreate);
350}

352DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
                              int64_t Lo, StorageType Storage,
                              bool ShouldCreate) {
auto *LB = ConstantAsMetadata::get(
    ConstantInt::getSigned(Type::getInt64Ty(Context), Lo));
return getImpl(Context, CountNode, LB, nullptr, nullptr, Storage,
               ShouldCreate);
359}

361DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode,
                              Metadata *LB, Metadata *UB, Metadata *Stride,
                              StorageType Storage, bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, LB, UB, Stride))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubranges, DISubrangeInfo::KeyTy(CountNode, LB, UB
, Stride))) return N; if (!ShouldCreate) return nullptr; } else
 { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {CountNode, LB, UB, Stride};
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DISubrange, Ops)return storeImpl(new (array_lengthof(Ops)) DISubrange(Context
, Storage, Ops), Storage, Context.pImpl->DISubranges);
367}

369DISubrange::BoundType DISubrange::getCount() const {
Metadata *CB = getRawCountNode();
if (!CB)
  return BoundType();

assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) ||(static_cast<void> (0))
        isa<DIExpression>(CB)) &&(static_cast<void> (0))
       "Count must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<ConstantAsMetadata>(CB))
  return BoundType(cast<ConstantInt>(MD->getValue()));

if (auto *MD = dyn_cast<DIVariable>(CB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(CB))
  return BoundType(MD);

return BoundType();
388}

390DISubrange::BoundType DISubrange::getLowerBound() const {
Metadata *LB = getRawLowerBound();
if (!LB)
  return BoundType();

assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) ||(static_cast<void> (0))
        isa<DIExpression>(LB)) &&(static_cast<void> (0))
       "LowerBound must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<ConstantAsMetadata>(LB))
  return BoundType(cast<ConstantInt>(MD->getValue()));

if (auto *MD = dyn_cast<DIVariable>(LB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(LB))
  return BoundType(MD);

return BoundType();
409}

411DISubrange::BoundType DISubrange::getUpperBound() const {
Metadata *UB = getRawUpperBound();
if (!UB)
  return BoundType();

assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) ||(static_cast<void> (0))
        isa<DIExpression>(UB)) &&(static_cast<void> (0))
       "UpperBound must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<ConstantAsMetadata>(UB))
  return BoundType(cast<ConstantInt>(MD->getValue()));

if (auto *MD = dyn_cast<DIVariable>(UB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(UB))
  return BoundType(MD);

return BoundType();
430}

432DISubrange::BoundType DISubrange::getStride() const {
Metadata *ST = getRawStride();
if (!ST)
  return BoundType();

assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) ||(static_cast<void> (0))
        isa<DIExpression>(ST)) &&(static_cast<void> (0))
       "Stride must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<ConstantAsMetadata>(ST))
  return BoundType(cast<ConstantInt>(MD->getValue()));

if (auto *MD = dyn_cast<DIVariable>(ST))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(ST))
  return BoundType(MD);

return BoundType();
451}

453DIGenericSubrange *DIGenericSubrange::getImpl(LLVMContext &Context,
                                            Metadata *CountNode, Metadata *LB,
                                            Metadata *UB, Metadata *Stride,
                                            StorageType Storage,
                                            bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DIGenericSubrange, (CountNode, LB, UB, Stride))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGenericSubranges, DIGenericSubrangeInfo::KeyTy(CountNode
, LB, UB, Stride))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {CountNode, LB, UB, Stride};
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGenericSubrange, Ops)return storeImpl(new (array_lengthof(Ops)) DIGenericSubrange(
Context, Storage, Ops), Storage, Context.pImpl->DIGenericSubranges
);
461}

463DIGenericSubrange::BoundType DIGenericSubrange::getCount() const {
Metadata *CB = getRawCountNode();
if (!CB)
  return BoundType();

assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) &&(static_cast<void> (0))
       "Count must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<DIVariable>(CB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(CB))
  return BoundType(MD);

return BoundType();
478}

480DIGenericSubrange::BoundType DIGenericSubrange::getLowerBound() const {
Metadata *LB = getRawLowerBound();
if (!LB)
  return BoundType();

assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) &&(static_cast<void> (0))
       "LowerBound must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<DIVariable>(LB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(LB))
  return BoundType(MD);

return BoundType();
495}

497DIGenericSubrange::BoundType DIGenericSubrange::getUpperBound() const {
Metadata *UB = getRawUpperBound();
if (!UB)
  return BoundType();

assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) &&(static_cast<void> (0))
       "UpperBound must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<DIVariable>(UB))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(UB))
  return BoundType(MD);

return BoundType();
512}

514DIGenericSubrange::BoundType DIGenericSubrange::getStride() const {
Metadata *ST = getRawStride();
if (!ST)
  return BoundType();

assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) &&(static_cast<void> (0))
       "Stride must be signed constant or DIVariable or DIExpression")(static_cast<void> (0));

if (auto *MD = dyn_cast<DIVariable>(ST))
  return BoundType(MD);

if (auto *MD = dyn_cast<DIExpression>(ST))
  return BoundType(MD);

return BoundType();
529}

531DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value,
                                  bool IsUnsigned, MDString *Name,
                                  StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIEnumerators, DIEnumeratorInfo::KeyTy(Value, IsUnsigned
, Name))) return N; if (!ShouldCreate) return nullptr; } else
 { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {Name};
DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops)return storeImpl(new (array_lengthof(Ops)) DIEnumerator(Context
, Storage, Value, IsUnsigned, Ops), Storage, Context.pImpl->
DIEnumerators);
538}

540DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
                                MDString *Name, uint64_t SizeInBits,
                                uint32_t AlignInBits, unsigned Encoding,
                                DIFlags Flags, StorageType Storage,
                                bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIBasicType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding, Flags))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                      (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits
, AlignInBits, Encoding, Flags))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false);
Metadata *Ops[] = {nullptr, nullptr, Name};
DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding,return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Flags, Ops
), Storage, Context.pImpl->DIBasicTypes)
                    Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Flags, Ops
), Storage, Context.pImpl->DIBasicTypes);
551}

553Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const {
switch (getEncoding()) {
case dwarf::DW_ATE_signed:
case dwarf::DW_ATE_signed_char:
  return Signedness::Signed;
case dwarf::DW_ATE_unsigned:
case dwarf::DW_ATE_unsigned_char:
  return Signedness::Unsigned;
default:
  return None;
}
564}

566DIStringType *DIStringType::getImpl(LLVMContext &Context, unsigned Tag,
                                  MDString *Name, Metadata *StringLength,
                                  Metadata *StringLengthExp,
                                  uint64_t SizeInBits, uint32_t AlignInBits,
                                  unsigned Encoding, StorageType Storage,
                                  bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIStringType, (Tag, Name, StringLength, StringLengthExp,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIStringTypes, DIStringTypeInfo::KeyTy(Tag, Name, StringLength
, StringLengthExp, SizeInBits, AlignInBits, Encoding))) return
 N; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)
                                     SizeInBits, AlignInBits, Encoding))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIStringTypes, DIStringTypeInfo::KeyTy(Tag, Name, StringLength
, StringLengthExp, SizeInBits, AlignInBits, Encoding))) return
 N; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false);
Metadata *Ops[] = {nullptr, nullptr, Name, StringLength, StringLengthExp};
DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding),return storeImpl(new (array_lengthof(Ops)) DIStringType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage
, Context.pImpl->DIStringTypes)
                     Ops)return storeImpl(new (array_lengthof(Ops)) DIStringType(Context
, Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage
, Context.pImpl->DIStringTypes);
578}

580DIDerivedType *DIDerivedType::getImpl(
  LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
  unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
  uint32_t AlignInBits, uint64_t OffsetInBits,
  Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData,
  Metadata *Annotations, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIDerivedType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData, Annotations))) return N
; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)
                      (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData, Annotations))) return N
; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)
                       AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData, Annotations))) return N
; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)
                       ExtraData, Annotations))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, DWARFAddressSpace, Flags, ExtraData, Annotations))) return N
; if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false);
Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData, Annotations};
DEFINE_GETIMPL_STORE(return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
    DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits,return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes)
                    DWARFAddressSpace, Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context
, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace
, Flags, Ops), Storage, Context.pImpl->DIDerivedTypes);
595}

597DICompositeType *DICompositeType::getImpl(
  LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
  unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
  uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
  Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
  Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator,
  Metadata *DataLocation, Metadata *Associated, Metadata *Allocated,
  Metadata *Rank, Metadata *Annotations, StorageType Storage,
  bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));

// Keep this in sync with buildODRType.
DEFINE_GETIMPL_LOOKUP(DICompositeType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                      (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                       AlignInBits, OffsetInBits, Flags, Elements,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                       RuntimeLang, VTableHolder, TemplateParams, Identifier,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                       Discriminator, DataLocation, Associated, Allocated,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                       Rank, Annotations))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name
, File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits
, Flags, Elements, RuntimeLang, VTableHolder, TemplateParams,
 Identifier, Discriminator, DataLocation, Associated, Allocated
, Rank, Annotations))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {File,          Scope,        Name,           BaseType,
                   Elements,      VTableHolder, TemplateParams, Identifier,
                   Discriminator, DataLocation, Associated,     Allocated,
                   Rank,          Annotations};
DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
                                       AlignInBits, OffsetInBits, Flags),return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes)
                     Ops)return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context
, Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits
, Flags, Ops), Storage, Context.pImpl->DICompositeTypes);
622}

624DICompositeType *DICompositeType::buildODRType(
  LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
  Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
  uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
  DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
  Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator,
  Metadata *DataLocation, Metadata *Associated, Metadata *Allocated,
  Metadata *Rank, Metadata *Annotations) {
assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast<void> (0));
if (!Context.isODRUniquingDebugTypes())
  return nullptr;
auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
if (!CT)
  return CT = DICompositeType::getDistinct(
             Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
             AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
             VTableHolder, TemplateParams, &Identifier, Discriminator,
             DataLocation, Associated, Allocated, Rank, Annotations);

// Only mutate CT if it's a forward declaration and the new operands aren't.
assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?")(static_cast<void> (0));
if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl))
  return CT;

// Mutate CT in place.  Keep this in sync with getImpl.
CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
           Flags);
Metadata *Ops[] = {File,          Scope,        Name,           BaseType,
                   Elements,      VTableHolder, TemplateParams, &Identifier,
                   Discriminator, DataLocation, Associated,     Allocated,
                   Rank,          Annotations};
assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&(static_cast<void> (0))
       "Mismatched number of operands")(static_cast<void> (0));
for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
  if (Ops[I] != CT->getOperand(I))
    CT->setOperand(I, Ops[I]);
return CT;
661}

663DICompositeType *DICompositeType::getODRType(
  LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
  Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
  uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
  DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
  Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator,
  Metadata *DataLocation, Metadata *Associated, Metadata *Allocated,
  Metadata *Rank, Metadata *Annotations) {
assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast<void> (0));
if (!Context.isODRUniquingDebugTypes())
  return nullptr;
auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
if (!CT)
  CT = DICompositeType::getDistinct(
      Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder,
      TemplateParams, &Identifier, Discriminator, DataLocation, Associated,
      Allocated, Rank, Annotations);
return CT;
682}

684DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context,
                                                   MDString &Identifier) {
assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast<void> (0));
if (!Context.isODRUniquingDebugTypes())
  return nullptr;
return Context.pImpl->DITypeMap->lookup(&Identifier);
690}

692DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
                                          uint8_t CC, Metadata *TypeArray,
                                          StorageType Storage,
                                          bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubroutineTypes, DISubroutineTypeInfo::KeyTy(Flags
, CC, TypeArray))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops)return storeImpl(new (array_lengthof(Ops)) DISubroutineType(Context
, Storage, Flags, CC, Ops), Storage, Context.pImpl->DISubroutineTypes
);
699}

701// FIXME: Implement this string-enum correspondence with a .def file and macros,
702// so that the association is explicit rather than implied.
703static const char *ChecksumKindName[DIFile::CSK_Last] = {
  "CSK_MD5",
  "CSK_SHA1",
  "CSK_SHA256",
707};

709StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind")(static_cast<void> (0));
// The first space was originally the CSK_None variant, which is now
// obsolete, but the space is still reserved in ChecksumKind, so we account
// for it here.
return ChecksumKindName[CSKind - 1];
715}

717Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) {
return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr)
    .Case("CSK_MD5", DIFile::CSK_MD5)
    .Case("CSK_SHA1", DIFile::CSK_SHA1)
    .Case("CSK_SHA256", DIFile::CSK_SHA256)
    .Default(None);
723}

725DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                      MDString *Directory,
                      Optional<DIFile::ChecksumInfo<MDString *>> CS,
                      Optional<MDString *> Source, StorageType Storage,
                      bool ShouldCreate) {
assert(isCanonical(Filename) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(Directory) && "Expected canonical MDString")(static_cast<void> (0));
assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString")(static_cast<void> (0));
assert((!Source || isCanonical(*Source)) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIFiles, DIFileInfo::KeyTy(Filename, Directory, CS
, Source))) return N; if (!ShouldCreate) return nullptr; } else
 { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr,
                   Source.getValueOr(nullptr)};
DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops)return storeImpl(new (array_lengthof(Ops)) DIFile(Context, Storage
, CS, Source, Ops), Storage, Context.pImpl->DIFiles);
738}

740DICompileUnit *DICompileUnit::getImpl(
  LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
  MDString *Producer, bool IsOptimized, MDString *Flags,
  unsigned RuntimeVersion, MDString *SplitDebugFilename,
  unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
  Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
  uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
  unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot,
  MDString *SDK, StorageType Storage, bool ShouldCreate) {
assert(Storage != Uniqued && "Cannot unique DICompileUnit")(static_cast<void> (0));
assert(isCanonical(Producer) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(Flags) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString")(static_cast<void> (0));

Metadata *Ops[] = {File,
                   Producer,
                   Flags,
                   SplitDebugFilename,
                   EnumTypes,
                   RetainedTypes,
                   GlobalVariables,
                   ImportedEntities,
                   Macros,
                   SysRoot,
                   SDK};
return storeImpl(new (array_lengthof(Ops)) DICompileUnit(
                     Context, Storage, SourceLanguage, IsOptimized,
                     RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
                     DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
                     Ops),
                 Storage);
771}

773Optional<DICompileUnit::DebugEmissionKind>
774DICompileUnit::getEmissionKind(StringRef Str) {
return StringSwitch<Optional<DebugEmissionKind>>(Str)
    .Case("NoDebug", NoDebug)
    .Case("FullDebug", FullDebug)
    .Case("LineTablesOnly", LineTablesOnly)
    .Case("DebugDirectivesOnly", DebugDirectivesOnly)
    .Default(None);
781}

783Optional<DICompileUnit::DebugNameTableKind>
784DICompileUnit::getNameTableKind(StringRef Str) {
return StringSwitch<Optional<DebugNameTableKind>>(Str)
    .Case("Default", DebugNameTableKind::Default)
    .Case("GNU", DebugNameTableKind::GNU)
    .Case("None", DebugNameTableKind::None)
    .Default(None);
790}

792const char *DICompileUnit::emissionKindString(DebugEmissionKind EK) {
switch (EK) {
case NoDebug:        return "NoDebug";
case FullDebug:      return "FullDebug";
case LineTablesOnly: return "LineTablesOnly";
case DebugDirectivesOnly: return "DebugDirectivesOnly";
}
return nullptr;
800}

802const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) {
switch (NTK) {
case DebugNameTableKind::Default:
  return nullptr;
case DebugNameTableKind::GNU:
  return "GNU";
case DebugNameTableKind::None:
  return "None";
}
return nullptr;
812}

814DISubprogram *DILocalScope::getSubprogram() const {
if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
  return Block->getScope()->getSubprogram();
return const_cast<DISubprogram *>(cast<DISubprogram>(this));
818}

820DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
if (auto *File = dyn_cast<DILexicalBlockFile>(this))
  return File->getScope()->getNonLexicalBlockFileScope();
return const_cast<DILocalScope *>(this);
824}

826DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) {
return StringSwitch<DISPFlags>(Flag)
828#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
829#include "llvm/IR/DebugInfoFlags.def"
    .Default(SPFlagZero);
831}

833StringRef DISubprogram::getFlagString(DISPFlags Flag) {
switch (Flag) {
// Appease a warning.
case SPFlagVirtuality:
  return "";
838#define HANDLE_DISP_FLAG(ID, NAME)                                             \
case SPFlag##NAME:                                                           \
  return "DISPFlag" #NAME;
841#include "llvm/IR/DebugInfoFlags.def"
}
return "";
844}

846DISubprogram::DISPFlags
847DISubprogram::splitFlags(DISPFlags Flags,
                       SmallVectorImpl<DISPFlags> &SplitFlags) {
// Multi-bit fields can require special handling. In our case, however, the
// only multi-bit field is virtuality, and all its values happen to be
// single-bit values, so the right behavior just falls out.
852#define HANDLE_DISP_FLAG(ID, NAME)                                             \
if (DISPFlags Bit = Flags & SPFlag##NAME) {                                  \
  SplitFlags.push_back(Bit);                                                 \
  Flags &= ~Bit;                                                             \
}
857#include "llvm/IR/DebugInfoFlags.def"
return Flags;
859}

861DISubprogram *DISubprogram::getImpl(
  LLVMContext &Context, Metadata *Scope, MDString *Name,
  MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
  unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
  int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
  Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
  Metadata *ThrownTypes, Metadata *Annotations, StorageType Storage,
  bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DISubprogram,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes, Annotations))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                      (Scope, Name, LinkageName, File, Line, Type, ScopeLine,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes, Annotations))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                       ContainingType, VirtualIndex, ThisAdjustment, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes, Annotations))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                       SPFlags, Unit, TemplateParams, Declaration,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes, Annotations))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                       RetainedNodes, ThrownTypes, Annotations))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name
, LinkageName, File, Line, Type, ScopeLine, ContainingType, VirtualIndex
, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, Declaration
, RetainedNodes, ThrownTypes, Annotations))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false);
SmallVector<Metadata *, 12> Ops = {
    File,        Scope,         Name,           LinkageName,    Type,       Unit,
    Declaration, RetainedNodes, ContainingType, TemplateParams, ThrownTypes,
    Annotations};
if (!Annotations) {
  Ops.pop_back();
  if (!ThrownTypes) {
    Ops.pop_back();
    if (!TemplateParams) {
      Ops.pop_back();
      if (!ContainingType)
        Ops.pop_back();
    }
  }
}
DEFINE_GETIMPL_STORE_N(return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
    DISubprogram,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
    (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms)
    Ops.size())return storeImpl(new (Ops.size()) DISubprogram(Context, Storage
, Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags
, Ops), Storage, Context.pImpl->DISubprograms);
895}

897bool DISubprogram::describes(const Function *F) const {
assert(F && "Invalid function")(static_cast<void> (0));
return F->getSubprogram() == this;
900}

902DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
                                      Metadata *File, unsigned Line,
                                      unsigned Column, StorageType Storage,
                                      bool ShouldCreate) {
// Fixup column.
adjustColumn(Column);

assert(Scope && "Expected scope")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILexicalBlocks, DILexicalBlockInfo::KeyTy(Scope, File
, Line, Column))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = {File, Scope};
DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlock(Context
, Storage, Line, Column, Ops), Storage, Context.pImpl->DILexicalBlocks
);
913}

915DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
                                              Metadata *Scope, Metadata *File,
                                              unsigned Discriminator,
                                              StorageType Storage,
                                              bool ShouldCreate) {
assert(Scope && "Expected scope")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILexicalBlockFiles, DILexicalBlockFileInfo::KeyTy
(Scope, File, Discriminator))) return N; if (!ShouldCreate) return
 nullptr; } else { (static_cast<void> (0)); } } while (
false);
Metadata *Ops[] = {File, Scope};
DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlockFile
(Context, Storage, Discriminator, Ops), Storage, Context.pImpl
->DILexicalBlockFiles);
924}

926DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
                                MDString *Name, bool ExportSymbols,
                                StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DINamespaces, DINamespaceInfo::KeyTy(Scope, Name, ExportSymbols
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
// The nullptr is for DIScope's File operand. This should be refactored.
Metadata *Ops[] = {nullptr, Scope, Name};
DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops)return storeImpl(new (array_lengthof(Ops)) DINamespace(Context
, Storage, ExportSymbols, Ops), Storage, Context.pImpl->DINamespaces
);
934}

936DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
                                    Metadata *Decl, MDString *Name,
                                    Metadata *File, unsigned LineNo,
                                    StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DICommonBlocks, DICommonBlockInfo::KeyTy(Scope, Decl
, Name, File, LineNo))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
// The nullptr is for DIScope's File operand. This should be refactored.
Metadata *Ops[] = {Scope, Decl, Name, File};
DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops)return storeImpl(new (array_lengthof(Ops)) DICommonBlock(Context
, Storage, LineNo, Ops), Storage, Context.pImpl->DICommonBlocks
);
945}

947DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File,
                          Metadata *Scope, MDString *Name,
                          MDString *ConfigurationMacros,
                          MDString *IncludePath, MDString *APINotesFile,
                          unsigned LineNo, bool IsDecl, StorageType Storage,
                          bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIModule, (File, Scope, Name, ConfigurationMacros,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(File, Scope, Name, ConfigurationMacros
, IncludePath, APINotesFile, LineNo, IsDecl))) return N; if (
!ShouldCreate) return nullptr; } else { (static_cast<void>
 (0)); } } while (false)
                                 IncludePath, APINotesFile, LineNo, IsDecl))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIModules, DIModuleInfo::KeyTy(File, Scope, Name, ConfigurationMacros
, IncludePath, APINotesFile, LineNo, IsDecl))) return N; if (
!ShouldCreate) return nullptr; } else { (static_cast<void>
 (0)); } } while (false);
Metadata *Ops[] = {File,        Scope,       Name, ConfigurationMacros,
                   IncludePath, APINotesFile};
DEFINE_GETIMPL_STORE(DIModule, (LineNo, IsDecl), Ops)return storeImpl(new (array_lengthof(Ops)) DIModule(Context, Storage
, LineNo, IsDecl, Ops), Storage, Context.pImpl->DIModules);
959}

961DITemplateTypeParameter *
962DITemplateTypeParameter::getImpl(LLVMContext &Context, MDString *Name,
                               Metadata *Type, bool isDefault,
                               StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type, isDefault))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DITemplateTypeParameters, DITemplateTypeParameterInfo
::KeyTy(Name, Type, isDefault))) return N; if (!ShouldCreate)
 return nullptr; } else { (static_cast<void> (0)); } } while
 (false);
Metadata *Ops[] = {Name, Type};
DEFINE_GETIMPL_STORE(DITemplateTypeParameter, (isDefault), Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateTypeParameter
(Context, Storage, isDefault, Ops), Storage, Context.pImpl->
DITemplateTypeParameters);
969}

971DITemplateValueParameter *DITemplateValueParameter::getImpl(
  LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
  bool isDefault, Metadata *Value, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DITemplateValueParameters, DITemplateValueParameterInfo
::KeyTy(Tag, Name, Type, isDefault, Value))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                      (Tag, Name, Type, isDefault, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DITemplateValueParameters, DITemplateValueParameterInfo
::KeyTy(Tag, Name, Type, isDefault, Value))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false);
Metadata *Ops[] = {Name, Type, Value};
DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag, isDefault), Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateValueParameter
(Context, Storage, Tag, isDefault, Ops), Storage, Context.pImpl
->DITemplateValueParameters);
979}

981DIGlobalVariable *
982DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
                        MDString *LinkageName, Metadata *File, unsigned Line,
                        Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
                        Metadata *StaticDataMemberDeclaration,
                        Metadata *TemplateParams, uint32_t AlignInBits,
                        Metadata *Annotations, StorageType Storage,
                        bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIGlobalVariable, (Scope, Name, LinkageName, File, Line,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                                         Type, IsLocalToUnit, IsDefinition,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                                         StaticDataMemberDeclaration,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                                         TemplateParams, AlignInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                                         Annotations))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope
, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition
, StaticDataMemberDeclaration, TemplateParams, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
Metadata *Ops[] = {Scope,
                   Name,
                   File,
                   Type,
                   Name,
                   LinkageName,
                   StaticDataMemberDeclaration,
                   TemplateParams,
                   Annotations};
DEFINE_GETIMPL_STORE(DIGlobalVariable,return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables)
                     (Line, IsLocalToUnit, IsDefinition, AlignInBits), Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context
, Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops
), Storage, Context.pImpl->DIGlobalVariables);
1007}

1009DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
                                        MDString *Name, Metadata *File,
                                        unsigned Line, Metadata *Type,
                                        unsigned Arg, DIFlags Flags,
                                        uint32_t AlignInBits,
                                        Metadata *Annotations,
                                        StorageType Storage,
                                        bool ShouldCreate) {
// 64K ought to be enough for any frontend.
assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits")(static_cast<void> (0));

assert(Scope && "Expected scope")(static_cast<void> (0));
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DILocalVariable,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                      (Scope, Name, File, Line, Type, Arg, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                       AlignInBits, Annotations))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope
, Name, File, Line, Type, Arg, Flags, AlignInBits, Annotations
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
Metadata *Ops[] = {Scope, Name, File, Type, Annotations};
DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops)return storeImpl(new (array_lengthof(Ops)) DILocalVariable(Context
, Storage, Line, Arg, Flags, AlignInBits, Ops), Storage, Context
.pImpl->DILocalVariables);
1027}

1029Optional<uint64_t> DIVariable::getSizeInBits() const {
// This is used by the Verifier so be mindful of broken types.
const Metadata *RawType = getRawType();
while (RawType) {
  // Try to get the size directly.
  if (auto *T = dyn_cast<DIType>(RawType))
    if (uint64_t Size = T->getSizeInBits())
      return Size;

  if (auto *DT = dyn_cast<DIDerivedType>(RawType)) {
    // Look at the base type.
    RawType = DT->getRawBaseType();
    continue;
  }

  // Missing type or size.
  break;
}

// Fail gracefully.
return None;
1050}

1052DILabel *DILabel::getImpl(LLVMContext &Context, Metadata *Scope,
                        MDString *Name, Metadata *File, unsigned Line,
                        StorageType Storage,
                        bool ShouldCreate) {
assert(Scope && "Expected scope")(static_cast<void> (0));
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DILabel,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILabels, DILabelInfo::KeyTy(Scope, Name, File, Line
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false)
                      (Scope, Name, File, Line))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DILabels, DILabelInfo::KeyTy(Scope, Name, File, Line
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
Metadata *Ops[] = {Scope, Name, File};
DEFINE_GETIMPL_STORE(DILabel, (Line), Ops)return storeImpl(new (array_lengthof(Ops)) DILabel(Context, Storage
, Line, Ops), Storage, Context.pImpl->DILabels);
1062}

1064DIExpression *DIExpression::getImpl(LLVMContext &Context,
                                  ArrayRef<uint64_t> Elements,
                                  StorageType Storage, bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIExpressions, DIExpressionInfo::KeyTy(Elements)))
 return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements))return storeImpl(new (0u) DIExpression(Context, Storage, Elements
), Storage, Context.pImpl->DIExpressions);
1069}

1071unsigned DIExpression::ExprOperand::getSize() const {
uint64_t Op = getOp();

if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
  return 2;

switch (Op) {
case dwarf::DW_OP_LLVM_convert:
case dwarf::DW_OP_LLVM_fragment:
case dwarf::DW_OP_bregx:
  return 3;
case dwarf::DW_OP_constu:
case dwarf::DW_OP_consts:
case dwarf::DW_OP_deref_size:
case dwarf::DW_OP_plus_uconst:
case dwarf::DW_OP_LLVM_tag_offset:
case dwarf::DW_OP_LLVM_entry_value:
case dwarf::DW_OP_LLVM_arg:
case dwarf::DW_OP_regx:
  return 2;
default:
  return 1;
}
1094}

1096bool DIExpression::isValid() const {
for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
  // Check that there's space for the operand.
  if (I->get() + I->getSize() > E->get())
    return false;

  uint64_t Op = I->getOp();
  if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) ||
      (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31))
    return true;

  // Check that the operand is valid.
  switch (Op) {
  default:
    return false;
  case dwarf::DW_OP_LLVM_fragment:
    // A fragment operator must appear at the end.
    return I->get() + I->getSize() == E->get();
  case dwarf::DW_OP_stack_value: {
    // Must be the last one or followed by a DW_OP_LLVM_fragment.
    if (I->get() + I->getSize() == E->get())
      break;
    auto J = I;
    if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment)
      return false;
    break;
  }
  case dwarf::DW_OP_swap: {
    // Must be more than one implicit element on the stack.

    // FIXME: A better way to implement this would be to add a local variable
    // that keeps track of the stack depth and introduce something like a
    // DW_LLVM_OP_implicit_location as a placeholder for the location this
    // DIExpression is attached to, or else pass the number of implicit stack
    // elements into isValid.
    if (getNumElements() == 1)
      return false;
    break;
  }
  case dwarf::DW_OP_LLVM_entry_value: {
    // An entry value operator must appear at the beginning and the number of
    // operations it cover can currently only be 1, because we support only
    // entry values of a simple register location. One reason for this is that
    // we currently can't calculate the size of the resulting DWARF block for
    // other expressions.
    return I->get() == expr_op_begin()->get() && I->getArg(0) == 1;
  }
  case dwarf::DW_OP_LLVM_implicit_pointer:
  case dwarf::DW_OP_LLVM_convert:
  case dwarf::DW_OP_LLVM_arg:
  case dwarf::DW_OP_LLVM_tag_offset:
  case dwarf::DW_OP_constu:
  case dwarf::DW_OP_plus_uconst:
  case dwarf::DW_OP_plus:
  case dwarf::DW_OP_minus:
  case dwarf::DW_OP_mul:
  case dwarf::DW_OP_div:
  case dwarf::DW_OP_mod:
  case dwarf::DW_OP_or:
  case dwarf::DW_OP_and:
  case dwarf::DW_OP_xor:
  case dwarf::DW_OP_shl:
  case dwarf::DW_OP_shr:
  case dwarf::DW_OP_shra:
  case dwarf::DW_OP_deref:
  case dwarf::DW_OP_deref_size:
  case dwarf::DW_OP_xderef:
  case dwarf::DW_OP_lit0:
  case dwarf::DW_OP_not:
  case dwarf::DW_OP_dup:
  case dwarf::DW_OP_regx:
  case dwarf::DW_OP_bregx:
  case dwarf::DW_OP_push_object_address:
  case dwarf::DW_OP_over:
  case dwarf::DW_OP_consts:
    break;
  }
}
return true;
1175}

1177bool DIExpression::isImplicit() const {
if (!isValid())
  return false;

if (getNumElements() == 0)
  return false;

for (const auto &It : expr_ops()) {
  switch (It.getOp()) {
  default:
    break;
  case dwarf::DW_OP_stack_value:
  case dwarf::DW_OP_LLVM_tag_offset:
    return true;
  }
}

return false;
1195}

1197bool DIExpression::isComplex() const {
if (!isValid())
  return false;

if (getNumElements() == 0)
  return false;

// If there are any elements other than fragment or tag_offset, then some
// kind of complex computation occurs.
for (const auto &It : expr_ops()) {
  switch (It.getOp()) {
    case dwarf::DW_OP_LLVM_tag_offset:
    case dwarf::DW_OP_LLVM_fragment:
      continue;
    default: return true;
  }
}

return false;
1216}

1218Optional<DIExpression::FragmentInfo>
1219DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) {
for (auto I = Start; I != End; ++I)
  if (I->getOp() == dwarf::DW_OP_LLVM_fragment) {
    DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)};
    return Info;
  }
return None;
1226}

1228void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
                              int64_t Offset) {
if (Offset > 0) {
  Ops.push_back(dwarf::DW_OP_plus_uconst);
  Ops.push_back(Offset);
} else if (Offset < 0) {
  Ops.push_back(dwarf::DW_OP_constu);
  Ops.push_back(-Offset);
  Ops.push_back(dwarf::DW_OP_minus);
}
1238}

1240bool DIExpression::extractIfOffset(int64_t &Offset) const {
if (getNumElements() == 0) {
  Offset = 0;
  return true;
}

if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
  Offset = Elements[1];
  return true;
}

if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
  if (Elements[2] == dwarf::DW_OP_plus) {
    Offset = Elements[1];
    return true;
  }
  if (Elements[2] == dwarf::DW_OP_minus) {
    Offset = -Elements[1];
    return true;
  }
}

return false;
1263}

1265bool DIExpression::hasAllLocationOps(unsigned N) const {
SmallDenseSet<uint64_t, 4> SeenOps;
for (auto ExprOp : expr_ops())
  if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
    SeenOps.insert(ExprOp.getArg(0));
for (uint64_t Idx = 0; Idx < N; ++Idx)
  if (!is_contained(SeenOps, Idx))
    return false;
return true;
1274}

1276const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,
                                                    unsigned &AddrClass) {
// FIXME: This seems fragile. Nothing that verifies that these elements
// actually map to ops and not operands.
const unsigned PatternSize = 4;
if (Expr->Elements.size() >= PatternSize &&
    Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu &&
    Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap &&
    Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) {
  AddrClass = Expr->Elements[PatternSize - 3];

  if (Expr->Elements.size() == PatternSize)
    return nullptr;
  return DIExpression::get(Expr->getContext(),
                           makeArrayRef(&*Expr->Elements.begin(),
                                        Expr->Elements.size() - PatternSize));
}
return Expr;
1294}

1296DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags,
                                  int64_t Offset) {
SmallVector<uint64_t, 8> Ops;
if (Flags & DIExpression::DerefBefore)
  Ops.push_back(dwarf::DW_OP_deref);

appendOffset(Ops, Offset);
if (Flags & DIExpression::DerefAfter)
  Ops.push_back(dwarf::DW_OP_deref);

bool StackValue = Flags & DIExpression::StackValue;
bool EntryValue = Flags & DIExpression::EntryValue;

return prependOpcodes(Expr, Ops, StackValue, EntryValue);
1310}

1312DIExpression *DIExpression::appendOpsToArg(const DIExpression *Expr,
                                         ArrayRef<uint64_t> Ops,
                                         unsigned ArgNo, bool StackValue) {
assert(Expr && "Can't add ops to this expression")(static_cast<void> (0));

// Handle non-variadic intrinsics by prepending the opcodes.
if (!any_of(Expr->expr_ops(),
            [](auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
  assert(ArgNo == 0 &&(static_cast<void> (0))
         "Location Index must be 0 for a non-variadic expression.")(static_cast<void> (0));
  SmallVector<uint64_t, 8> NewOps(Ops.begin(), Ops.end());
  return DIExpression::prependOpcodes(Expr, NewOps, StackValue);
}

SmallVector<uint64_t, 8> NewOps;
for (auto Op : Expr->expr_ops()) {
  Op.appendToVector(NewOps);
  if (Op.getOp() == dwarf::DW_OP_LLVM_arg && Op.getArg(0) == ArgNo)
    NewOps.insert(NewOps.end(), Ops.begin(), Ops.end());
}

return DIExpression::get(Expr->getContext(), NewOps);
1334}

1336DIExpression *DIExpression::replaceArg(const DIExpression *Expr,
                                     uint64_t OldArg, uint64_t NewArg) {
assert(Expr && "Can't replace args in this expression")(static_cast<void> (0));

SmallVector<uint64_t, 8> NewOps;

for (auto Op : Expr->expr_ops()) {
  if (Op.getOp() != dwarf::DW_OP_LLVM_arg || Op.getArg(0) < OldArg) {
    Op.appendToVector(NewOps);
    continue;
  }
  NewOps.push_back(dwarf::DW_OP_LLVM_arg);
  uint64_t Arg = Op.getArg(0) == OldArg ? NewArg : Op.getArg(0);
  // OldArg has been deleted from the Op list, so decrement all indices
  // greater than it.
  if (Arg > OldArg)
    --Arg;
  NewOps.push_back(Arg);
}
return DIExpression::get(Expr->getContext(), NewOps);
1356}

1358DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
                                         SmallVectorImpl<uint64_t> &Ops,
                                         bool StackValue,
                                         bool EntryValue) {
assert(Expr && "Can't prepend ops to this expression")(static_cast<void> (0));

if (EntryValue) {
  Ops.push_back(dwarf::DW_OP_LLVM_entry_value);
  // Use a block size of 1 for the target register operand.  The
  // DWARF backend currently cannot emit entry values with a block
  // size > 1.
  Ops.push_back(1);
}

// If there are no ops to prepend, do not even add the DW_OP_stack_value.
if (Ops.empty())
  StackValue = false;
for (auto Op : Expr->expr_ops()) {
  // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
  if (StackValue) {
    if (Op.getOp() == dwarf::DW_OP_stack_value)
      StackValue = false;
    else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
      Ops.push_back(dwarf::DW_OP_stack_value);
      StackValue = false;
    }
  }
  Op.appendToVector(Ops);
}
if (StackValue)
  Ops.push_back(dwarf::DW_OP_stack_value);
return DIExpression::get(Expr->getContext(), Ops);
1390}

1392DIExpression *DIExpression::append(const DIExpression *Expr,
                                 ArrayRef<uint64_t> Ops) {
assert(Expr && !Ops.empty() && "Can't append ops to this expression")(static_cast<void> (0));

// Copy Expr's current op list.
SmallVector<uint64_t, 16> NewOps;
for (auto Op : Expr->expr_ops()) {
  // Append new opcodes before DW_OP_{stack_value, LLVM_fragment}.
  if (Op.getOp() == dwarf::DW_OP_stack_value ||
      Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
    NewOps.append(Ops.begin(), Ops.end());

    // Ensure that the new opcodes are only appended once.
    Ops = None;
  }
  Op.appendToVector(NewOps);
}

NewOps.append(Ops.begin(), Ops.end());
auto *result = DIExpression::get(Expr->getContext(), NewOps);
assert(result->isValid() && "concatenated expression is not valid")(static_cast<void> (0));
return result;
1414}

1416DIExpression *DIExpression::appendToStack(const DIExpression *Expr,
                                        ArrayRef<uint64_t> Ops) {
assert(Expr && !Ops.empty() && "Can't append ops to this expression")(static_cast<void> (0));
assert(none_of(Ops,(static_cast<void> (0))
               [](uint64_t Op) {(static_cast<void> (0))
                 return Op == dwarf::DW_OP_stack_value ||(static_cast<void> (0))
                        Op == dwarf::DW_OP_LLVM_fragment;(static_cast<void> (0))
               }) &&(static_cast<void> (0))
       "Can't append this op")(static_cast<void> (0));

// Append a DW_OP_deref after Expr's current op list if it's non-empty and
// has no DW_OP_stack_value.
//
// Match .* DW_OP_stack_value (DW_OP_LLVM_fragment A B)?.
Optional<FragmentInfo> FI = Expr->getFragmentInfo();
unsigned DropUntilStackValue = FI.hasValue() ? 3 : 0;
ArrayRef<uint64_t> ExprOpsBeforeFragment =
    Expr->getElements().drop_back(DropUntilStackValue);
bool NeedsDeref = (Expr->getNumElements() > DropUntilStackValue) &&
                  (ExprOpsBeforeFragment.back() != dwarf::DW_OP_stack_value);
bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.empty();

// Append a DW_OP_deref after Expr's current op list if needed, then append
// the new ops, and finally ensure that a single DW_OP_stack_value is present.
SmallVector<uint64_t, 16> NewOps;
if (NeedsDeref)
  NewOps.push_back(dwarf::DW_OP_deref);
NewOps.append(Ops.begin(), Ops.end());
if (NeedsStackValue)
  NewOps.push_back(dwarf::DW_OP_stack_value);
return DIExpression::append(Expr, NewOps);
1447}

1449Optional<DIExpression *> DIExpression::createFragmentExpression(
  const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
SmallVector<uint64_t, 8> Ops;
// Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
if (Expr) {
1
Assuming 'Expr' is null→
2
←
Taking false branch→
  for (auto Op : Expr->expr_ops()) {
    switch (Op.getOp()) {
    default: break;
    case dwarf::DW_OP_shr:
    case dwarf::DW_OP_shra:
    case dwarf::DW_OP_shl:
    case dwarf::DW_OP_plus:
    case dwarf::DW_OP_plus_uconst:
    case dwarf::DW_OP_minus:
      // We can't safely split arithmetic or shift operations into multiple
      // fragments because we can't express carry-over between fragments.
      //
      // FIXME: We *could* preserve the lowest fragment of a constant offset
      // operation if the offset fits into SizeInBits.
      return None;
    case dwarf::DW_OP_LLVM_fragment: {
      // Make the new offset point into the existing fragment.
      uint64_t FragmentOffsetInBits = Op.getArg(0);
      uint64_t FragmentSizeInBits = Op.getArg(1);
      (void)FragmentSizeInBits;
      assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&(static_cast<void> (0))
             "new fragment outside of original fragment")(static_cast<void> (0));
      OffsetInBits += FragmentOffsetInBits;
      continue;
    }
    }
    Op.appendToVector(Ops);
  }
}
assert(Expr && "Unknown DIExpression")(static_cast<void> (0));
Ops.push_back(dwarf::DW_OP_LLVM_fragment);
Ops.push_back(OffsetInBits);
Ops.push_back(SizeInBits);
return DIExpression::get(Expr->getContext(), Ops);
3
←
Called C++ object pointer is null
1488}

1490std::pair<DIExpression *, const ConstantInt *>
1491DIExpression::constantFold(const ConstantInt *CI) {
// Copy the APInt so we can modify it.
APInt NewInt = CI->getValue();
SmallVector<uint64_t, 8> Ops;

// Fold operators only at the beginning of the expression.
bool First = true;
bool Changed = false;
for (auto Op : expr_ops()) {
  switch (Op.getOp()) {
  default:
    // We fold only the leading part of the expression; if we get to a part
    // that we're going to copy unchanged, and haven't done any folding,
    // then the entire expression is unchanged and we can return early.
    if (!Changed)
      return {this, CI};
    First = false;
    break;
  case dwarf::DW_OP_LLVM_convert:
    if (!First)
      break;
    Changed = true;
    if (Op.getArg(1) == dwarf::DW_ATE_signed)
      NewInt = NewInt.sextOrTrunc(Op.getArg(0));
    else {
      assert(Op.getArg(1) == dwarf::DW_ATE_unsigned && "Unexpected operand")(static_cast<void> (0));
      NewInt = NewInt.zextOrTrunc(Op.getArg(0));
    }
    continue;
  }
  Op.appendToVector(Ops);
}
if (!Changed)
  return {this, CI};
return {DIExpression::get(getContext(), Ops),
        ConstantInt::get(getContext(), NewInt)};
1527}

1529uint64_t DIExpression::getNumLocationOperands() const {
uint64_t Result = 0;
for (auto ExprOp : expr_ops())
  if (ExprOp.getOp() == dwarf::DW_OP_LLVM_arg)
    Result = std::max(Result, ExprOp.getArg(0) + 1);
assert(hasAllLocationOps(Result) &&(static_cast<void> (0))
       "Expression is missing one or more location operands.")(static_cast<void> (0));
return Result;
1537}

1539llvm::Optional<DIExpression::SignedOrUnsignedConstant>
1540DIExpression::isConstant() const {

// Recognize signed and unsigned constants.
// An signed constants can be represented as DW_OP_consts C DW_OP_stack_value
// (DW_OP_LLVM_fragment of Len).
// An unsigned constant can be represented as
// DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment of Len).

if ((getNumElements() != 2 && getNumElements() != 3 &&
     getNumElements() != 6) ||
    (getElement(0) != dwarf::DW_OP_consts &&
     getElement(0) != dwarf::DW_OP_constu))
  return None;

if (getNumElements() == 2 && getElement(0) == dwarf::DW_OP_consts)
  return SignedOrUnsignedConstant::SignedConstant;

if ((getNumElements() == 3 && getElement(2) != dwarf::DW_OP_stack_value) ||
    (getNumElements() == 6 && (getElement(2) != dwarf::DW_OP_stack_value ||
                               getElement(3) != dwarf::DW_OP_LLVM_fragment)))
  return None;
return getElement(0) == dwarf::DW_OP_constu
           ? SignedOrUnsignedConstant::UnsignedConstant
           : SignedOrUnsignedConstant::SignedConstant;
1564}

1566DIExpression::ExtOps DIExpression::getExtOps(unsigned FromSize, unsigned ToSize,
                                           bool Signed) {
dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
DIExpression::ExtOps Ops{{dwarf::DW_OP_LLVM_convert, FromSize, TK,
                          dwarf::DW_OP_LLVM_convert, ToSize, TK}};
return Ops;
1572}

1574DIExpression *DIExpression::appendExt(const DIExpression *Expr,
                                    unsigned FromSize, unsigned ToSize,
                                    bool Signed) {
return appendToStack(Expr, getExtOps(FromSize, ToSize, Signed));
1578}

1580DIGlobalVariableExpression *
1581DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable,
                                  Metadata *Expression, StorageType Storage,
                                  bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIGlobalVariableExpressions, DIGlobalVariableExpressionInfo
::KeyTy(Variable, Expression))) return N; if (!ShouldCreate) return
 nullptr; } else { (static_cast<void> (0)); } } while (
false);
Metadata *Ops[] = {Variable, Expression};
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariableExpression
(Context, Storage, Ops), Storage, Context.pImpl->DIGlobalVariableExpressions
);
1587}

1589DIObjCProperty *DIObjCProperty::getImpl(
  LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
  MDString *GetterName, MDString *SetterName, unsigned Attributes,
  Metadata *Type, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(GetterName) && "Expected canonical MDString")(static_cast<void> (0));
assert(isCanonical(SetterName) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File
, Line, GetterName, SetterName, Attributes, Type))) return N;
 if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false)
                                       SetterName, Attributes, Type))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File
, Line, GetterName, SetterName, Attributes, Type))) return N;
 if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false);
Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops)return storeImpl(new (array_lengthof(Ops)) DIObjCProperty(Context
, Storage, Line, Attributes, Ops), Storage, Context.pImpl->
DIObjCPropertys);
1600}

1602DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
                                          Metadata *Scope, Metadata *Entity,
                                          Metadata *File, unsigned Line,
                                          MDString *Name, StorageType Storage,
                                          bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIImportedEntity,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag
, Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false)
                      (Tag, Scope, Entity, File, Line, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag
, Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate
) return nullptr; } else { (static_cast<void> (0)); } }
 while (false);
Metadata *Ops[] = {Scope, Entity, Name, File};
DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIImportedEntity(Context
, Storage, Tag, Line, Ops), Storage, Context.pImpl->DIImportedEntitys
);
1612}

1614DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
                        unsigned Line, MDString *Name, MDString *Value,
                        StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString")(static_cast<void> (0));
DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacros, DIMacroInfo::KeyTy(MIType, Line, Name, Value
))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast
<void> (0)); } } while (false);
Metadata *Ops[] = { Name, Value };
DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacro(Context, Storage
, MIType, Line, Ops), Storage, Context.pImpl->DIMacros);
1621}

1623DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
                                unsigned Line, Metadata *File,
                                Metadata *Elements, StorageType Storage,
                                bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DIMacroFile,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line,
 File, Elements))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false)
                      (MIType, Line, File, Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line,
 File, Elements))) return N; if (!ShouldCreate) return nullptr
; } else { (static_cast<void> (0)); } } while (false);
Metadata *Ops[] = { File, Elements };
DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacroFile(Context
, Storage, MIType, Line, Ops), Storage, Context.pImpl->DIMacroFiles
);
1631}

1633DIArgList *DIArgList::getImpl(LLVMContext &Context,
                            ArrayRef<ValueAsMetadata *> Args,
                            StorageType Storage, bool ShouldCreate) {
DEFINE_GETIMPL_LOOKUP(DIArgList, (Args))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context
.pImpl->DIArgLists, DIArgListInfo::KeyTy(Args))) return N;
 if (!ShouldCreate) return nullptr; } else { (static_cast<
void> (0)); } } while (false);
DEFINE_GETIMPL_STORE_NO_OPS(DIArgList, (Args))return storeImpl(new (0u) DIArgList(Context, Storage, Args), Storage
, Context.pImpl->DIArgLists);
1638}

1640void DIArgList::handleChangedOperand(void *Ref, Metadata *New) {
ValueAsMetadata **OldVMPtr = static_cast<ValueAsMetadata **>(Ref);
assert((!New || isa<ValueAsMetadata>(New)) &&(static_cast<void> (0))
       "DIArgList must be passed a ValueAsMetadata")(static_cast<void> (0));
untrack();
bool Uniq = isUniqued();
if (Uniq) {
  // We need to update the uniqueness once the Args are updated since they
  // form the key to the DIArgLists store.
  eraseFromStore();
}
ValueAsMetadata *NewVM = cast_or_null<ValueAsMetadata>(New);
for (ValueAsMetadata *&VM : Args) {
  if (&VM == OldVMPtr) {
    if (NewVM)
      VM = NewVM;
    else
      VM = ValueAsMetadata::get(UndefValue::get(VM->getValue()->getType()));
  }
}
if (Uniq) {
  if (uniquify() != this)
    storeDistinctInContext();
}
track();
1665}
1666void DIArgList::track() {
for (ValueAsMetadata *&VAM : Args)
  if (VAM)
    MetadataTracking::track(&VAM, *VAM, *this);
1670}
1671void DIArgList::untrack() {
for (ValueAsMetadata *&VAM : Args)
  if (VAM)
    MetadataTracking::untrack(&VAM, *VAM);
1675}
1676void DIArgList::dropAllReferences() {
untrack();
Args.clear();
MDNode::dropAllReferences();
1680}