/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader/MetadataLoader.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
Warning:	line 1079, column 11 1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name MetadataLoader.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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U 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-15/lib/clang/15.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 -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -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-15~++20220420111733+e13d2efed663/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -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-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader/MetadataLoader.cpp

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Bitcode/Reader/MetadataLoader.cpp

→

1//===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
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//===----------------------------------------------------------------------===//

9#include "MetadataLoader.h"
10#include "ValueList.h"

12#include "llvm/ADT/APInt.h"
13#include "llvm/ADT/ArrayRef.h"
14#include "llvm/ADT/BitmaskEnum.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/DenseSet.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/Optional.h"
19#include "llvm/ADT/STLFunctionalExtras.h"
20#include "llvm/ADT/SmallString.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/Statistic.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/ADT/ilist_iterator.h"
26#include "llvm/ADT/iterator_range.h"
27#include "llvm/BinaryFormat/Dwarf.h"
28#include "llvm/Bitcode/BitcodeReader.h"
29#include "llvm/Bitcode/LLVMBitCodes.h"
30#include "llvm/Bitstream/BitstreamReader.h"
31#include "llvm/IR/AutoUpgrade.h"
32#include "llvm/IR/BasicBlock.h"
33#include "llvm/IR/Constants.h"
34#include "llvm/IR/DebugInfoMetadata.h"
35#include "llvm/IR/Function.h"
36#include "llvm/IR/GlobalObject.h"
37#include "llvm/IR/GlobalVariable.h"
38#include "llvm/IR/Instruction.h"
39#include "llvm/IR/IntrinsicInst.h"
40#include "llvm/IR/LLVMContext.h"
41#include "llvm/IR/Metadata.h"
42#include "llvm/IR/Module.h"
43#include "llvm/IR/TrackingMDRef.h"
44#include "llvm/IR/Type.h"
45#include "llvm/Support/Casting.h"
46#include "llvm/Support/CommandLine.h"
47#include "llvm/Support/Compiler.h"
48#include "llvm/Support/ErrorHandling.h"
49#include "llvm/Support/type_traits.h"

51#include <algorithm>
52#include <cassert>
53#include <cstddef>
54#include <cstdint>
55#include <deque>
56#include <iterator>
57#include <limits>
58#include <string>
59#include <tuple>
60#include <type_traits>
61#include <utility>
62#include <vector>
63namespace llvm {
64class Argument;
65}

67using namespace llvm;

69#define DEBUG_TYPE"bitcode-reader" "bitcode-reader"

71STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded")static llvm::Statistic NumMDStringLoaded = {"bitcode-reader",
 "NumMDStringLoaded", "Number of MDStrings loaded"};
72STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created")static llvm::Statistic NumMDNodeTemporary = {"bitcode-reader"
, "NumMDNodeTemporary", "Number of MDNode::Temporary created"
};
73STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded")static llvm::Statistic NumMDRecordLoaded = {"bitcode-reader",
 "NumMDRecordLoaded", "Number of Metadata records loaded"};

75/// Flag whether we need to import full type definitions for ThinLTO.
76/// Currently needed for Darwin and LLDB.
77static cl::opt<bool> ImportFullTypeDefinitions(
  "import-full-type-definitions", cl::init(false), cl::Hidden,
  cl::desc("Import full type definitions for ThinLTO."));

81static cl::opt<bool> DisableLazyLoading(
  "disable-ondemand-mds-loading", cl::init(false), cl::Hidden,
  cl::desc("Force disable the lazy-loading on-demand of metadata when "
           "loading bitcode for importing."));

86namespace {

88static int64_t unrotateSign(uint64_t U) { return (U & 1) ? ~(U >> 1) : U >> 1; }

90class BitcodeReaderMetadataList {
/// Array of metadata references.
///
/// Don't use std::vector here.  Some versions of libc++ copy (instead of
/// move) on resize, and TrackingMDRef is very expensive to copy.
SmallVector<TrackingMDRef, 1> MetadataPtrs;

/// The set of indices in MetadataPtrs above of forward references that were
/// generated.
SmallDenseSet<unsigned, 1> ForwardReference;

/// The set of indices in MetadataPtrs above of Metadata that need to be
/// resolved.
SmallDenseSet<unsigned, 1> UnresolvedNodes;

/// Structures for resolving old type refs.
struct {
  SmallDenseMap<MDString *, TempMDTuple, 1> Unknown;
  SmallDenseMap<MDString *, DICompositeType *, 1> Final;
  SmallDenseMap<MDString *, DICompositeType *, 1> FwdDecls;
  SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
} OldTypeRefs;

LLVMContext &Context;

/// Maximum number of valid references. Forward references exceeding the
/// maximum must be invalid.
unsigned RefsUpperBound;

119public:
BitcodeReaderMetadataList(LLVMContext &C, size_t RefsUpperBound)
    : Context(C),
      RefsUpperBound(std::min((size_t)std::numeric_limits<unsigned>::max(),
                              RefsUpperBound)) {}

// vector compatibility methods
unsigned size() const { return MetadataPtrs.size(); }
void resize(unsigned N) { MetadataPtrs.resize(N); }
void push_back(Metadata *MD) { MetadataPtrs.emplace_back(MD); }
void clear() { MetadataPtrs.clear(); }
Metadata *back() const { return MetadataPtrs.back(); }
void pop_back() { MetadataPtrs.pop_back(); }
bool empty() const { return MetadataPtrs.empty(); }

Metadata *operator[](unsigned i) const {
  assert(i < MetadataPtrs.size())(static_cast <bool> (i < MetadataPtrs.size()) ? void
 (0) : __assert_fail ("i < MetadataPtrs.size()", "llvm/lib/Bitcode/Reader/MetadataLoader.cpp"
, 135, __extension__ __PRETTY_FUNCTION__));
  return MetadataPtrs[i];
}

Metadata *lookup(unsigned I) const {
  if (I < MetadataPtrs.size())
31
←
Taking false branch→
    return MetadataPtrs[I];
  return nullptr;
32
←
Returning null pointer, which participates in a condition later→
}

void shrinkTo(unsigned N) {
  assert(N <= size() && "Invalid shrinkTo request!")(static_cast <bool> (N <= size() && "Invalid shrinkTo request!"
) ? void (0) : __assert_fail ("N <= size() && \"Invalid shrinkTo request!\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 146, __extension__
 __PRETTY_FUNCTION__));
  assert(ForwardReference.empty() && "Unexpected forward refs")(static_cast <bool> (ForwardReference.empty() &&
 "Unexpected forward refs") ? void (0) : __assert_fail ("ForwardReference.empty() && \"Unexpected forward refs\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 147, __extension__
 __PRETTY_FUNCTION__));
  assert(UnresolvedNodes.empty() && "Unexpected unresolved node")(static_cast <bool> (UnresolvedNodes.empty() &&
 "Unexpected unresolved node") ? void (0) : __assert_fail ("UnresolvedNodes.empty() && \"Unexpected unresolved node\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 148, __extension__
 __PRETTY_FUNCTION__));
  MetadataPtrs.resize(N);
}

/// Return the given metadata, creating a replaceable forward reference if
/// necessary.
Metadata *getMetadataFwdRef(unsigned Idx);

/// Return the given metadata only if it is fully resolved.
///
/// Gives the same result as \a lookup(), unless \a MDNode::isResolved()
/// would give \c false.
Metadata *getMetadataIfResolved(unsigned Idx);

MDNode *getMDNodeFwdRefOrNull(unsigned Idx);
void assignValue(Metadata *MD, unsigned Idx);
void tryToResolveCycles();
bool hasFwdRefs() const { return !ForwardReference.empty(); }
int getNextFwdRef() {
  assert(hasFwdRefs())(static_cast <bool> (hasFwdRefs()) ? void (0) : __assert_fail
 ("hasFwdRefs()", "llvm/lib/Bitcode/Reader/MetadataLoader.cpp"
, 167, __extension__ __PRETTY_FUNCTION__));
  return *ForwardReference.begin();
}

/// Upgrade a type that had an MDString reference.
void addTypeRef(MDString &UUID, DICompositeType &CT);

/// Upgrade a type that had an MDString reference.
Metadata *upgradeTypeRef(Metadata *MaybeUUID);

/// Upgrade a type ref array that may have MDString references.
Metadata *upgradeTypeRefArray(Metadata *MaybeTuple);

180private:
Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
182};

184void BitcodeReaderMetadataList::assignValue(Metadata *MD, unsigned Idx) {
if (auto *MDN = dyn_cast<MDNode>(MD))
  if (!MDN->isResolved())
    UnresolvedNodes.insert(Idx);

if (Idx == size()) {
  push_back(MD);
  return;
}

if (Idx >= size())
  resize(Idx + 1);

TrackingMDRef &OldMD = MetadataPtrs[Idx];
if (!OldMD) {
  OldMD.reset(MD);
  return;
}

// If there was a forward reference to this value, replace it.
TempMDTuple PrevMD(cast<MDTuple>(OldMD.get()));
PrevMD->replaceAllUsesWith(MD);
ForwardReference.erase(Idx);
207}

209Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
// Bail out for a clearly invalid value.
if (Idx >= RefsUpperBound)
  return nullptr;

if (Idx >= size())
  resize(Idx + 1);

if (Metadata *MD = MetadataPtrs[Idx])
  return MD;

// Track forward refs to be resolved later.
ForwardReference.insert(Idx);

// Create and return a placeholder, which will later be RAUW'd.
++NumMDNodeTemporary;
Metadata *MD = MDNode::getTemporary(Context, None).release();
MetadataPtrs[Idx].reset(MD);
return MD;
228}

230Metadata *BitcodeReaderMetadataList::getMetadataIfResolved(unsigned Idx) {
Metadata *MD = lookup(Idx);
if (auto *N = dyn_cast_or_null<MDNode>(MD))
  if (!N->isResolved())
    return nullptr;
return MD;
236}

238MDNode *BitcodeReaderMetadataList::getMDNodeFwdRefOrNull(unsigned Idx) {
return dyn_cast_or_null<MDNode>(getMetadataFwdRef(Idx));
240}

242void BitcodeReaderMetadataList::tryToResolveCycles() {
if (!ForwardReference.empty())
  // Still forward references... can't resolve cycles.
  return;

// Give up on finding a full definition for any forward decls that remain.
for (const auto &Ref : OldTypeRefs.FwdDecls)
  OldTypeRefs.Final.insert(Ref);
OldTypeRefs.FwdDecls.clear();

// Upgrade from old type ref arrays.  In strange cases, this could add to
// OldTypeRefs.Unknown.
for (const auto &Array : OldTypeRefs.Arrays)
  Array.second->replaceAllUsesWith(resolveTypeRefArray(Array.first.get()));
OldTypeRefs.Arrays.clear();

// Replace old string-based type refs with the resolved node, if possible.
// If we haven't seen the node, leave it to the verifier to complain about
// the invalid string reference.
for (const auto &Ref : OldTypeRefs.Unknown) {
  if (DICompositeType *CT = OldTypeRefs.Final.lookup(Ref.first))
    Ref.second->replaceAllUsesWith(CT);
  else
    Ref.second->replaceAllUsesWith(Ref.first);
}
OldTypeRefs.Unknown.clear();

if (UnresolvedNodes.empty())
  // Nothing to do.
  return;

// Resolve any cycles.
for (unsigned I : UnresolvedNodes) {
  auto &MD = MetadataPtrs[I];
  auto *N = dyn_cast_or_null<MDNode>(MD);
  if (!N)
    continue;

  assert(!N->isTemporary() && "Unexpected forward reference")(static_cast <bool> (!N->isTemporary() && "Unexpected forward reference"
) ? void (0) : __assert_fail ("!N->isTemporary() && \"Unexpected forward reference\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 280, __extension__
 __PRETTY_FUNCTION__));
  N->resolveCycles();
}

// Make sure we return early again until there's another unresolved ref.
UnresolvedNodes.clear();
286}

288void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
                                         DICompositeType &CT) {
assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID")(static_cast <bool> (CT.getRawIdentifier() == &UUID
 && "Mismatched UUID") ? void (0) : __assert_fail ("CT.getRawIdentifier() == &UUID && \"Mismatched UUID\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 290, __extension__
 __PRETTY_FUNCTION__));
if (CT.isForwardDecl())
  OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
else
  OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
295}

297Metadata *BitcodeReaderMetadataList::upgradeTypeRef(Metadata *MaybeUUID) {
auto *UUID = dyn_cast_or_null<MDString>(MaybeUUID);
if (LLVM_LIKELY(!UUID)__builtin_expect((bool)(!UUID), true))
  return MaybeUUID;

if (auto *CT = OldTypeRefs.Final.lookup(UUID))
  return CT;

auto &Ref = OldTypeRefs.Unknown[UUID];
if (!Ref)
  Ref = MDNode::getTemporary(Context, None);
return Ref.get();
309}

311Metadata *BitcodeReaderMetadataList::upgradeTypeRefArray(Metadata *MaybeTuple) {
auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
if (!Tuple || Tuple->isDistinct())
  return MaybeTuple;

// Look through the array immediately if possible.
if (!Tuple->isTemporary())
  return resolveTypeRefArray(Tuple);

// Create and return a placeholder to use for now.  Eventually
// resolveTypeRefArrays() will be resolve this forward reference.
OldTypeRefs.Arrays.emplace_back(
    std::piecewise_construct, std::forward_as_tuple(Tuple),
    std::forward_as_tuple(MDTuple::getTemporary(Context, None)));
return OldTypeRefs.Arrays.back().second.get();
326}

328Metadata *BitcodeReaderMetadataList::resolveTypeRefArray(Metadata *MaybeTuple) {
auto *Tuple = dyn_cast_or_null<MDTuple>(MaybeTuple);
if (!Tuple || Tuple->isDistinct())
  return MaybeTuple;

// Look through the DITypeRefArray, upgrading each DIType *.
SmallVector<Metadata *, 32> Ops;
Ops.reserve(Tuple->getNumOperands());
for (Metadata *MD : Tuple->operands())
  Ops.push_back(upgradeTypeRef(MD));

return MDTuple::get(Context, Ops);
340}

342namespace {

344class PlaceholderQueue {
// Placeholders would thrash around when moved, so store in a std::deque
// instead of some sort of vector.
std::deque<DistinctMDOperandPlaceholder> PHs;

349public:
~PlaceholderQueue() {
  assert(empty() &&(static_cast <bool> (empty() && "PlaceholderQueue hasn't been flushed before being destroyed"
) ? void (0) : __assert_fail ("empty() && \"PlaceholderQueue hasn't been flushed before being destroyed\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 352, __extension__
 __PRETTY_FUNCTION__))
         "PlaceholderQueue hasn't been flushed before being destroyed")(static_cast <bool> (empty() && "PlaceholderQueue hasn't been flushed before being destroyed"
) ? void (0) : __assert_fail ("empty() && \"PlaceholderQueue hasn't been flushed before being destroyed\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 352, __extension__
 __PRETTY_FUNCTION__));
}
bool empty() const { return PHs.empty(); }
DistinctMDOperandPlaceholder &getPlaceholderOp(unsigned ID);
void flush(BitcodeReaderMetadataList &MetadataList);

/// Return the list of temporaries nodes in the queue, these need to be
/// loaded before we can flush the queue.
void getTemporaries(BitcodeReaderMetadataList &MetadataList,
                    DenseSet<unsigned> &Temporaries) {
  for (auto &PH : PHs) {
    auto ID = PH.getID();
    auto *MD = MetadataList.lookup(ID);
    if (!MD) {
      Temporaries.insert(ID);
      continue;
    }
    auto *N = dyn_cast_or_null<MDNode>(MD);
    if (N && N->isTemporary())
      Temporaries.insert(ID);
  }
}
374};

376} // end anonymous namespace

378DistinctMDOperandPlaceholder &PlaceholderQueue::getPlaceholderOp(unsigned ID) {
PHs.emplace_back(ID);
return PHs.back();
381}

383void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
while (!PHs.empty()) {
  auto *MD = MetadataList.lookup(PHs.front().getID());
  assert(MD && "Flushing placeholder on unassigned MD")(static_cast <bool> (MD && "Flushing placeholder on unassigned MD"
) ? void (0) : __assert_fail ("MD && \"Flushing placeholder on unassigned MD\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 386, __extension__
 __PRETTY_FUNCTION__));
387#ifndef NDEBUG
  if (auto *MDN = dyn_cast<MDNode>(MD))
    assert(MDN->isResolved() &&(static_cast <bool> (MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? void (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 390, __extension__
 __PRETTY_FUNCTION__))
           "Flushing Placeholder while cycles aren't resolved")(static_cast <bool> (MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? void (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 390, __extension__
 __PRETTY_FUNCTION__));
391#endif
  PHs.front().replaceUseWith(MD);
  PHs.pop_front();
}
395}

397} // anonymous namespace

399static Error error(const Twine &Message) {
return make_error<StringError>(
    Message, make_error_code(BitcodeError::CorruptedBitcode));
402}

404class MetadataLoader::MetadataLoaderImpl {
BitcodeReaderMetadataList MetadataList;
BitcodeReaderValueList &ValueList;
BitstreamCursor &Stream;
LLVMContext &Context;
Module &TheModule;
std::function<Type *(unsigned)> getTypeByID;

/// Cursor associated with the lazy-loading of Metadata. This is the easy way
/// to keep around the right "context" (Abbrev list) to be able to jump in
/// the middle of the metadata block and load any record.
BitstreamCursor IndexCursor;

/// Index that keeps track of MDString values.
std::vector<StringRef> MDStringRef;

/// On-demand loading of a single MDString. Requires the index above to be
/// populated.
MDString *lazyLoadOneMDString(unsigned Idx);

/// Index that keeps track of where to find a metadata record in the stream.
std::vector<uint64_t> GlobalMetadataBitPosIndex;

/// Cursor position of the start of the global decl attachments, to enable
/// loading using the index built for lazy loading, instead of forward
/// references.
uint64_t GlobalDeclAttachmentPos = 0;

432#ifndef NDEBUG
/// Baisic correctness check that we end up parsing all of the global decl
/// attachments.
unsigned NumGlobalDeclAttachSkipped = 0;
unsigned NumGlobalDeclAttachParsed = 0;
437#endif

/// Load the global decl attachments, using the index built for lazy loading.
Expected<bool> loadGlobalDeclAttachments();

/// Populate the index above to enable lazily loading of metadata, and load
/// the named metadata as well as the transitively referenced global
/// Metadata.
Expected<bool> lazyLoadModuleMetadataBlock();

/// On-demand loading of a single metadata. Requires the index above to be
/// populated.
void lazyLoadOneMetadata(unsigned Idx, PlaceholderQueue &Placeholders);

// Keep mapping of seens pair of old-style CU <-> SP, and update pointers to
// point from SP to CU after a block is completly parsed.
std::vector<std::pair<DICompileUnit *, Metadata *>> CUSubprograms;

/// Functions that need to be matched with subprograms when upgrading old
/// metadata.
SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;

// Map the bitcode's custom MDKind ID to the Module's MDKind ID.
DenseMap<unsigned, unsigned> MDKindMap;

bool StripTBAA = false;
bool HasSeenOldLoopTags = false;
bool NeedUpgradeToDIGlobalVariableExpression = false;
bool NeedDeclareExpressionUpgrade = false;

/// True if metadata is being parsed for a module being ThinLTO imported.
bool IsImporting = false;

Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
                       PlaceholderQueue &Placeholders, StringRef Blob,
                       unsigned &NextMetadataNo);
Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
                           function_ref<void(StringRef)> CallBack);
Error parseGlobalObjectAttachment(GlobalObject &GO,
                                  ArrayRef<uint64_t> Record);
Error parseMetadataKindRecord(SmallVectorImpl<uint64_t> &Record);

void resolveForwardRefsAndPlaceholders(PlaceholderQueue &Placeholders);

/// Upgrade old-style CU <-> SP pointers to point from SP to CU.
void upgradeCUSubprograms() {
  for (auto CU_SP : CUSubprograms)
    if (auto *SPs = dyn_cast_or_null<MDTuple>(CU_SP.second))
      for (auto &Op : SPs->operands())
        if (auto *SP = dyn_cast_or_null<DISubprogram>(Op))
          SP->replaceUnit(CU_SP.first);
  CUSubprograms.clear();
}

/// Upgrade old-style bare DIGlobalVariables to DIGlobalVariableExpressions.
void upgradeCUVariables() {
  if (!NeedUpgradeToDIGlobalVariableExpression)
    return;

  // Upgrade list of variables attached to the CUs.
  if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
    for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
      auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
      if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
        for (unsigned I = 0; I < GVs->getNumOperands(); I++)
          if (auto *GV =
                  dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
            auto *DGVE = DIGlobalVariableExpression::getDistinct(
                Context, GV, DIExpression::get(Context, {}));
            GVs->replaceOperandWith(I, DGVE);
          }
    }

  // Upgrade variables attached to globals.
  for (auto &GV : TheModule.globals()) {
    SmallVector<MDNode *, 1> MDs;
    GV.getMetadata(LLVMContext::MD_dbg, MDs);
    GV.eraseMetadata(LLVMContext::MD_dbg);
    for (auto *MD : MDs)
      if (auto *DGV = dyn_cast<DIGlobalVariable>(MD)) {
        auto *DGVE = DIGlobalVariableExpression::getDistinct(
            Context, DGV, DIExpression::get(Context, {}));
        GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
      } else
        GV.addMetadata(LLVMContext::MD_dbg, *MD);
  }
}

/// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that
/// describes a function argument.
void upgradeDeclareExpressions(Function &F) {
  if (!NeedDeclareExpressionUpgrade)
    return;

  for (auto &BB : F)
    for (auto &I : BB)
      if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
        if (auto *DIExpr = DDI->getExpression())
          if (DIExpr->startsWithDeref() &&
              isa_and_nonnull<Argument>(DDI->getAddress())) {
            SmallVector<uint64_t, 8> Ops;
            Ops.append(std::next(DIExpr->elements_begin()),
                       DIExpr->elements_end());
            DDI->setExpression(DIExpression::get(Context, Ops));
          }
}

/// Upgrade the expression from previous versions.
Error upgradeDIExpression(uint64_t FromVersion,
                          MutableArrayRef<uint64_t> &Expr,
                          SmallVectorImpl<uint64_t> &Buffer) {
  auto N = Expr.size();
  switch (FromVersion) {
  default:
    return error("Invalid record");
  case 0:
    if (N >= 3 && Expr[N - 3] == dwarf::DW_OP_bit_piece)
      Expr[N - 3] = dwarf::DW_OP_LLVM_fragment;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case 1:
    // Move DW_OP_deref to the end.
    if (N && Expr[0] == dwarf::DW_OP_deref) {
      auto End = Expr.end();
      if (Expr.size() >= 3 &&
          *std::prev(End, 3) == dwarf::DW_OP_LLVM_fragment)
        End = std::prev(End, 3);
      std::move(std::next(Expr.begin()), End, Expr.begin());
      *std::prev(End) = dwarf::DW_OP_deref;
    }
    NeedDeclareExpressionUpgrade = true;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case 2: {
    // Change DW_OP_plus to DW_OP_plus_uconst.
    // Change DW_OP_minus to DW_OP_uconst, DW_OP_minus
    auto SubExpr = ArrayRef<uint64_t>(Expr);
    while (!SubExpr.empty()) {
      // Skip past other operators with their operands
      // for this version of the IR, obtained from
      // from historic DIExpression::ExprOperand::getSize().
      size_t HistoricSize;
      switch (SubExpr.front()) {
      default:
        HistoricSize = 1;
        break;
      case dwarf::DW_OP_constu:
      case dwarf::DW_OP_minus:
      case dwarf::DW_OP_plus:
        HistoricSize = 2;
        break;
      case dwarf::DW_OP_LLVM_fragment:
        HistoricSize = 3;
        break;
      }

      // If the expression is malformed, make sure we don't
      // copy more elements than we should.
      HistoricSize = std::min(SubExpr.size(), HistoricSize);
      ArrayRef<uint64_t> Args = SubExpr.slice(1, HistoricSize - 1);

      switch (SubExpr.front()) {
      case dwarf::DW_OP_plus:
        Buffer.push_back(dwarf::DW_OP_plus_uconst);
        Buffer.append(Args.begin(), Args.end());
        break;
      case dwarf::DW_OP_minus:
        Buffer.push_back(dwarf::DW_OP_constu);
        Buffer.append(Args.begin(), Args.end());
        Buffer.push_back(dwarf::DW_OP_minus);
        break;
      default:
        Buffer.push_back(*SubExpr.begin());
        Buffer.append(Args.begin(), Args.end());
        break;
      }

      // Continue with remaining elements.
      SubExpr = SubExpr.slice(HistoricSize);
    }
    Expr = MutableArrayRef<uint64_t>(Buffer);
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  }
  case 3:
    // Up-to-date!
    break;
  }

  return Error::success();
}

void upgradeDebugInfo() {
  upgradeCUSubprograms();
  upgradeCUVariables();
}

631public:
MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
                   BitcodeReaderValueList &ValueList,
                   std::function<Type *(unsigned)> getTypeByID,
                   bool IsImporting)
    : MetadataList(TheModule.getContext(), Stream.SizeInBytes()),
      ValueList(ValueList), Stream(Stream), Context(TheModule.getContext()),
      TheModule(TheModule), getTypeByID(std::move(getTypeByID)),
      IsImporting(IsImporting) {}

Error parseMetadata(bool ModuleLevel);

bool hasFwdRefs() const { return MetadataList.hasFwdRefs(); }

Metadata *getMetadataFwdRefOrLoad(unsigned ID) {
  if (ID < MDStringRef.size())
20
←
Assuming the condition is false→
21
←
Taking false branch→
    return lazyLoadOneMDString(ID);
  if (auto *MD21.1
'MD' is null
1
'MD' is null
 = MetadataList.lookup(ID))
22
←
Taking false branch→
    return MD;
  // If lazy-loading is enabled, we try recursively to load the operand
  // instead of creating a temporary.
  if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
23
←
Assuming the condition is true→
24
←
Taking true branch→
    PlaceholderQueue Placeholders;
    lazyLoadOneMetadata(ID, Placeholders);
25
←
Calling 'MetadataLoaderImpl::lazyLoadOneMetadata'→
    resolveForwardRefsAndPlaceholders(Placeholders);
    return MetadataList.lookup(ID);
  }
  return MetadataList.getMetadataFwdRef(ID);
}

DISubprogram *lookupSubprogramForFunction(Function *F) {
  return FunctionsWithSPs.lookup(F);
}

bool hasSeenOldLoopTags() const { return HasSeenOldLoopTags; }

Error parseMetadataAttachment(Function &F,
                              ArrayRef<Instruction *> InstructionList);

Error parseMetadataKinds();

void setStripTBAA(bool Value) { StripTBAA = Value; }
bool isStrippingTBAA() const { return StripTBAA; }

unsigned size() const { return MetadataList.size(); }
void shrinkTo(unsigned N) { MetadataList.shrinkTo(N); }
void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
678};

680Expected<bool>
681MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
IndexCursor = Stream;
SmallVector<uint64_t, 64> Record;
GlobalDeclAttachmentPos = 0;
// Get the abbrevs, and preload record positions to make them lazy-loadable.
while (true) {
  uint64_t SavedPos = IndexCursor.GetCurrentBitNo();
  BitstreamEntry Entry;
  if (Error E =
          IndexCursor
              .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
              .moveInto(Entry))
    return std::move(E);

  switch (Entry.Kind) {
  case BitstreamEntry::SubBlock: // Handled for us already.
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock: {
    return true;
  }
  case BitstreamEntry::Record: {
    // The interesting case.
    ++NumMDRecordLoaded;
    uint64_t CurrentPos = IndexCursor.GetCurrentBitNo();
    unsigned Code;
    if (Error E = IndexCursor.skipRecord(Entry.ID).moveInto(Code))
      return std::move(E);
    switch (Code) {
    case bitc::METADATA_STRINGS: {
      // Rewind and parse the strings.
      if (Error Err = IndexCursor.JumpToBit(CurrentPos))
        return std::move(Err);
      StringRef Blob;
      Record.clear();
      if (Expected<unsigned> MaybeRecord =
              IndexCursor.readRecord(Entry.ID, Record, &Blob))
        ;
      else
        return MaybeRecord.takeError();
      unsigned NumStrings = Record[0];
      MDStringRef.reserve(NumStrings);
      auto IndexNextMDString = [&](StringRef Str) {
        MDStringRef.push_back(Str);
      };
      if (auto Err = parseMetadataStrings(Record, Blob, IndexNextMDString))
        return std::move(Err);
      break;
    }
    case bitc::METADATA_INDEX_OFFSET: {
      // This is the offset to the index, when we see this we skip all the
      // records and load only an index to these.
      if (Error Err = IndexCursor.JumpToBit(CurrentPos))
        return std::move(Err);
      Record.clear();
      if (Expected<unsigned> MaybeRecord =
              IndexCursor.readRecord(Entry.ID, Record))
        ;
      else
        return MaybeRecord.takeError();
      if (Record.size() != 2)
        return error("Invalid record");
      auto Offset = Record[0] + (Record[1] << 32);
      auto BeginPos = IndexCursor.GetCurrentBitNo();
      if (Error Err = IndexCursor.JumpToBit(BeginPos + Offset))
        return std::move(Err);
      Expected<BitstreamEntry> MaybeEntry =
          IndexCursor.advanceSkippingSubblocks(
              BitstreamCursor::AF_DontPopBlockAtEnd);
      if (!MaybeEntry)
        return MaybeEntry.takeError();
      Entry = MaybeEntry.get();
      assert(Entry.Kind == BitstreamEntry::Record &&(static_cast <bool> (Entry.Kind == BitstreamEntry::Record
 && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? void (0) : __assert_fail ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 755, __extension__
 __PRETTY_FUNCTION__))
             "Corrupted bitcode: Expected `Record` when trying to find the "(static_cast <bool> (Entry.Kind == BitstreamEntry::Record
 && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? void (0) : __assert_fail ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 755, __extension__
 __PRETTY_FUNCTION__))
             "Metadata index")(static_cast <bool> (Entry.Kind == BitstreamEntry::Record
 && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? void (0) : __assert_fail ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 755, __extension__
 __PRETTY_FUNCTION__));
      Record.clear();
      if (Expected<unsigned> MaybeCode =
              IndexCursor.readRecord(Entry.ID, Record))
        assert(MaybeCode.get() == bitc::METADATA_INDEX &&(static_cast <bool> (MaybeCode.get() == bitc::METADATA_INDEX
 && "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
 "find the Metadata index") ? void (0) : __assert_fail ("MaybeCode.get() == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected `METADATA_INDEX` when trying to \" \"find the Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 761, __extension__
 __PRETTY_FUNCTION__))
               "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "(static_cast <bool> (MaybeCode.get() == bitc::METADATA_INDEX
 && "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
 "find the Metadata index") ? void (0) : __assert_fail ("MaybeCode.get() == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected `METADATA_INDEX` when trying to \" \"find the Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 761, __extension__
 __PRETTY_FUNCTION__))
               "find the Metadata index")(static_cast <bool> (MaybeCode.get() == bitc::METADATA_INDEX
 && "Corrupted bitcode: Expected `METADATA_INDEX` when trying to "
 "find the Metadata index") ? void (0) : __assert_fail ("MaybeCode.get() == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected `METADATA_INDEX` when trying to \" \"find the Metadata index\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 761, __extension__
 __PRETTY_FUNCTION__));
      else
        return MaybeCode.takeError();
      // Delta unpack
      auto CurrentValue = BeginPos;
      GlobalMetadataBitPosIndex.reserve(Record.size());
      for (auto &Elt : Record) {
        CurrentValue += Elt;
        GlobalMetadataBitPosIndex.push_back(CurrentValue);
      }
      break;
    }
    case bitc::METADATA_INDEX:
      // We don't expect to get there, the Index is loaded when we encounter
      // the offset.
      return error("Corrupted Metadata block");
    case bitc::METADATA_NAME: {
      // Named metadata need to be materialized now and aren't deferred.
      if (Error Err = IndexCursor.JumpToBit(CurrentPos))
        return std::move(Err);
      Record.clear();

      unsigned Code;
      if (Expected<unsigned> MaybeCode =
              IndexCursor.readRecord(Entry.ID, Record)) {
        Code = MaybeCode.get();
        assert(Code == bitc::METADATA_NAME)(static_cast <bool> (Code == bitc::METADATA_NAME) ? void
 (0) : __assert_fail ("Code == bitc::METADATA_NAME", "llvm/lib/Bitcode/Reader/MetadataLoader.cpp"
, 787, __extension__ __PRETTY_FUNCTION__));
      } else
        return MaybeCode.takeError();

      // Read name of the named metadata.
      SmallString<8> Name(Record.begin(), Record.end());
      if (Expected<unsigned> MaybeCode = IndexCursor.ReadCode())
        Code = MaybeCode.get();
      else
        return MaybeCode.takeError();

      // Named Metadata comes in two parts, we expect the name to be followed
      // by the node
      Record.clear();
      if (Expected<unsigned> MaybeNextBitCode =
              IndexCursor.readRecord(Code, Record))
        assert(MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE)(static_cast <bool> (MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE
) ? void (0) : __assert_fail ("MaybeNextBitCode.get() == bitc::METADATA_NAMED_NODE"
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 803, __extension__
 __PRETTY_FUNCTION__));
      else
        return MaybeNextBitCode.takeError();

      // Read named metadata elements.
      unsigned Size = Record.size();
      NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
      for (unsigned i = 0; i != Size; ++i) {
        // FIXME: We could use a placeholder here, however NamedMDNode are
        // taking MDNode as operand and not using the Metadata infrastructure.
        // It is acknowledged by 'TODO: Inherit from Metadata' in the
        // NamedMDNode class definition.
        MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
        assert(MD && "Invalid metadata: expect fwd ref to MDNode")(static_cast <bool> (MD && "Invalid metadata: expect fwd ref to MDNode"
) ? void (0) : __assert_fail ("MD && \"Invalid metadata: expect fwd ref to MDNode\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 816, __extension__
 __PRETTY_FUNCTION__));
        NMD->addOperand(MD);
      }
      break;
    }
    case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
      if (!GlobalDeclAttachmentPos)
        GlobalDeclAttachmentPos = SavedPos;
824#ifndef NDEBUG
      NumGlobalDeclAttachSkipped++;
826#endif
      break;
    }
    case bitc::METADATA_KIND:
    case bitc::METADATA_STRING_OLD:
    case bitc::METADATA_OLD_FN_NODE:
    case bitc::METADATA_OLD_NODE:
    case bitc::METADATA_VALUE:
    case bitc::METADATA_DISTINCT_NODE:
    case bitc::METADATA_NODE:
    case bitc::METADATA_LOCATION:
    case bitc::METADATA_GENERIC_DEBUG:
    case bitc::METADATA_SUBRANGE:
    case bitc::METADATA_ENUMERATOR:
    case bitc::METADATA_BASIC_TYPE:
    case bitc::METADATA_STRING_TYPE:
    case bitc::METADATA_DERIVED_TYPE:
    case bitc::METADATA_COMPOSITE_TYPE:
    case bitc::METADATA_SUBROUTINE_TYPE:
    case bitc::METADATA_MODULE:
    case bitc::METADATA_FILE:
    case bitc::METADATA_COMPILE_UNIT:
    case bitc::METADATA_SUBPROGRAM:
    case bitc::METADATA_LEXICAL_BLOCK:
    case bitc::METADATA_LEXICAL_BLOCK_FILE:
    case bitc::METADATA_NAMESPACE:
    case bitc::METADATA_COMMON_BLOCK:
    case bitc::METADATA_MACRO:
    case bitc::METADATA_MACRO_FILE:
    case bitc::METADATA_TEMPLATE_TYPE:
    case bitc::METADATA_TEMPLATE_VALUE:
    case bitc::METADATA_GLOBAL_VAR:
    case bitc::METADATA_LOCAL_VAR:
    case bitc::METADATA_LABEL:
    case bitc::METADATA_EXPRESSION:
    case bitc::METADATA_OBJC_PROPERTY:
    case bitc::METADATA_IMPORTED_ENTITY:
    case bitc::METADATA_GLOBAL_VAR_EXPR:
    case bitc::METADATA_GENERIC_SUBRANGE:
      // We don't expect to see any of these, if we see one, give up on
      // lazy-loading and fallback.
      MDStringRef.clear();
      GlobalMetadataBitPosIndex.clear();
      return false;
    }
    break;
  }
  }
}
875}

877// Load the global decl attachments after building the lazy loading index.
878// We don't load them "lazily" - all global decl attachments must be
879// parsed since they aren't materialized on demand. However, by delaying
880// their parsing until after the index is created, we can use the index
881// instead of creating temporaries.
882Expected<bool> MetadataLoader::MetadataLoaderImpl::loadGlobalDeclAttachments() {
// Nothing to do if we didn't find any of these metadata records.
if (!GlobalDeclAttachmentPos)
  return true;
// Use a temporary cursor so that we don't mess up the main Stream cursor or
// the lazy loading IndexCursor (which holds the necessary abbrev ids).
BitstreamCursor TempCursor = Stream;
SmallVector<uint64_t, 64> Record;
// Jump to the position before the first global decl attachment, so we can
// scan for the first BitstreamEntry record.
if (Error Err = TempCursor.JumpToBit(GlobalDeclAttachmentPos))
  return std::move(Err);
while (true) {
  BitstreamEntry Entry;
  if (Error E =
          TempCursor
              .advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd)
              .moveInto(Entry))
    return std::move(E);

  switch (Entry.Kind) {
  case BitstreamEntry::SubBlock: // Handled for us already.
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    // Check that we parsed them all.
    assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed)(static_cast <bool> (NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed
) ? void (0) : __assert_fail ("NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed"
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 908, __extension__
 __PRETTY_FUNCTION__));
    return true;
  case BitstreamEntry::Record:
    break;
  }
  uint64_t CurrentPos = TempCursor.GetCurrentBitNo();
  Expected<unsigned> MaybeCode = TempCursor.skipRecord(Entry.ID);
  if (!MaybeCode)
    return MaybeCode.takeError();
  if (MaybeCode.get() != bitc::METADATA_GLOBAL_DECL_ATTACHMENT) {
    // Anything other than a global decl attachment signals the end of
    // these records. Check that we parsed them all.
    assert(NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed)(static_cast <bool> (NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed
) ? void (0) : __assert_fail ("NumGlobalDeclAttachSkipped == NumGlobalDeclAttachParsed"
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 920, __extension__
 __PRETTY_FUNCTION__));
    return true;
  }
923#ifndef NDEBUG
  NumGlobalDeclAttachParsed++;
925#endif
  // FIXME: we need to do this early because we don't materialize global
  // value explicitly.
  if (Error Err = TempCursor.JumpToBit(CurrentPos))
    return std::move(Err);
  Record.clear();
  if (Expected<unsigned> MaybeRecord =
          TempCursor.readRecord(Entry.ID, Record))
    ;
  else
    return MaybeRecord.takeError();
  if (Record.size() % 2 == 0)
    return error("Invalid record");
  unsigned ValueID = Record[0];
  if (ValueID >= ValueList.size())
    return error("Invalid record");
  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID])) {
    // Need to save and restore the current position since
    // parseGlobalObjectAttachment will resolve all forward references which
    // would require parsing from locations stored in the index.
    CurrentPos = TempCursor.GetCurrentBitNo();
    if (Error Err = parseGlobalObjectAttachment(
            *GO, ArrayRef<uint64_t>(Record).slice(1)))
      return std::move(Err);
    if (Error Err = TempCursor.JumpToBit(CurrentPos))
      return std::move(Err);
  }
}
953}

955/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
956/// module level metadata.
957Error MetadataLoader::MetadataLoaderImpl::parseMetadata(bool ModuleLevel) {
if (!ModuleLevel && MetadataList.hasFwdRefs())
  return error("Invalid metadata: fwd refs into function blocks");

// Record the entry position so that we can jump back here and efficiently
// skip the whole block in case we lazy-load.
auto EntryPos = Stream.GetCurrentBitNo();

if (Error Err = Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
  return Err;

SmallVector<uint64_t, 64> Record;
PlaceholderQueue Placeholders;

// We lazy-load module-level metadata: we build an index for each record, and
// then load individual record as needed, starting with the named metadata.
if (ModuleLevel && IsImporting && MetadataList.empty() &&
    !DisableLazyLoading) {
  auto SuccessOrErr = lazyLoadModuleMetadataBlock();
  if (!SuccessOrErr)
    return SuccessOrErr.takeError();
  if (SuccessOrErr.get()) {
    // An index was successfully created and we will be able to load metadata
    // on-demand.
    MetadataList.resize(MDStringRef.size() +
                        GlobalMetadataBitPosIndex.size());

    // Now that we have built the index, load the global decl attachments
    // that were deferred during that process. This avoids creating
    // temporaries.
    SuccessOrErr = loadGlobalDeclAttachments();
    if (!SuccessOrErr)
      return SuccessOrErr.takeError();
    assert(SuccessOrErr.get())(static_cast <bool> (SuccessOrErr.get()) ? void (0) : __assert_fail
 ("SuccessOrErr.get()", "llvm/lib/Bitcode/Reader/MetadataLoader.cpp"
, 990, __extension__ __PRETTY_FUNCTION__));

    // Reading the named metadata created forward references and/or
    // placeholders, that we flush here.
    resolveForwardRefsAndPlaceholders(Placeholders);
    upgradeDebugInfo();
    // Return at the beginning of the block, since it is easy to skip it
    // entirely from there.
    Stream.ReadBlockEnd(); // Pop the abbrev block context.
    if (Error Err = IndexCursor.JumpToBit(EntryPos))
      return Err;
    if (Error Err = Stream.SkipBlock()) {
      // FIXME this drops the error on the floor, which
      // ThinLTO/X86/debuginfo-cu-import.ll relies on.
      consumeError(std::move(Err));
      return Error::success();
    }
    return Error::success();
  }
  // Couldn't load an index, fallback to loading all the block "old-style".
}

unsigned NextMetadataNo = MetadataList.size();

// Read all the records.
while (true) {
  BitstreamEntry Entry;
  if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
    return E;

  switch (Entry.Kind) {
  case BitstreamEntry::SubBlock: // Handled for us already.
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    resolveForwardRefsAndPlaceholders(Placeholders);
    upgradeDebugInfo();
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  StringRef Blob;
  ++NumMDRecordLoaded;
  if (Expected<unsigned> MaybeCode =
          Stream.readRecord(Entry.ID, Record, &Blob)) {
    if (Error Err = parseOneMetadata(Record, MaybeCode.get(), Placeholders,
                                     Blob, NextMetadataNo))
      return Err;
  } else
    return MaybeCode.takeError();
}
1045}

1047MDString *MetadataLoader::MetadataLoaderImpl::lazyLoadOneMDString(unsigned ID) {
++NumMDStringLoaded;
if (Metadata *MD = MetadataList.lookup(ID))
  return cast<MDString>(MD);
auto MDS = MDString::get(Context, MDStringRef[ID]);
MetadataList.assignValue(MDS, ID);
return MDS;
1054}

1056void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
  unsigned ID, PlaceholderQueue &Placeholders) {
assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size())(static_cast <bool> (ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex
.size()) ? void (0) : __assert_fail ("ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()"
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 1058, __extension__
 __PRETTY_FUNCTION__));
26
←
Assuming the condition is true→
27
←
'?' condition is true→
assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString")(static_cast <bool> (ID >= MDStringRef.size() &&
 "Unexpected lazy-loading of MDString") ? void (0) : __assert_fail
 ("ID >= MDStringRef.size() && \"Unexpected lazy-loading of MDString\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 1059, __extension__
 __PRETTY_FUNCTION__));
28
←
Assuming the condition is true→
29
←
'?' condition is true→
// Lookup first if the metadata hasn't already been loaded.
if (auto *MD33.1
'MD' is null
1
'MD' is null
 = MetadataList.lookup(ID)) {
30
←
Calling 'BitcodeReaderMetadataList::lookup'→
33
←
Returning from 'BitcodeReaderMetadataList::lookup'→
34
←
Taking false branch→
  auto *N = cast<MDNode>(MD);
  if (!N->isTemporary())
    return;
}
SmallVector<uint64_t, 64> Record;
StringRef Blob;
if (Error Err = IndexCursor.JumpToBit(
35
←
Assuming the condition is false→
36
←
Taking false branch→
        GlobalMetadataBitPosIndex[ID - MDStringRef.size()]))
  report_fatal_error("lazyLoadOneMetadata failed jumping: " +
                     Twine(toString(std::move(Err))));
BitstreamEntry Entry;
if (Error E = IndexCursor.advanceSkippingSubblocks().moveInto(Entry))
37
←
Calling 'Expected::moveInto'→
40
←
Returning from 'Expected::moveInto'→
41
←
Assuming the condition is false→
42
←
Taking false branch→
  // FIXME this drops the error on the floor.
  report_fatal_error("lazyLoadOneMetadata failed advanceSkippingSubblocks: " +
                     Twine(toString(std::move(E))));
++NumMDRecordLoaded;
if (Expected<unsigned> MaybeCode =
        IndexCursor.readRecord(Entry.ID, Record, &Blob)) {
43
←
1st function call argument is an uninitialized value
  if (Error Err =
          parseOneMetadata(Record, MaybeCode.get(), Placeholders, Blob, ID))
    report_fatal_error("Can't lazyload MD, parseOneMetadata: " +
                       Twine(toString(std::move(Err))));
} else
  report_fatal_error("Can't lazyload MD: " +
                     Twine(toString(MaybeCode.takeError())));
1087}

1089/// Ensure that all forward-references and placeholders are resolved.
1090/// Iteratively lazy-loading metadata on-demand if needed.
1091void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
  PlaceholderQueue &Placeholders) {
DenseSet<unsigned> Temporaries;
while (true) {
  // Populate Temporaries with the placeholders that haven't been loaded yet.
  Placeholders.getTemporaries(MetadataList, Temporaries);

  // If we don't have any temporary, or FwdReference, we're done!
  if (Temporaries.empty() && !MetadataList.hasFwdRefs())
    break;

  // First, load all the temporaries. This can add new placeholders or
  // forward references.
  for (auto ID : Temporaries)
    lazyLoadOneMetadata(ID, Placeholders);
  Temporaries.clear();

  // Second, load the forward-references. This can also add new placeholders
  // or forward references.
  while (MetadataList.hasFwdRefs())
    lazyLoadOneMetadata(MetadataList.getNextFwdRef(), Placeholders);
}
// At this point we don't have any forward reference remaining, or temporary
// that haven't been loaded. We can safely drop RAUW support and mark cycles
// as resolved.
MetadataList.tryToResolveCycles();

// Finally, everything is in place, we can replace the placeholders operands
// with the final node they refer to.
Placeholders.flush(MetadataList);
1121}

1123Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
  SmallVectorImpl<uint64_t> &Record, unsigned Code,
  PlaceholderQueue &Placeholders, StringRef Blob, unsigned &NextMetadataNo) {

bool IsDistinct = false;
auto getMD = [&](unsigned ID) -> Metadata * {
  if (ID < MDStringRef.size())
    return lazyLoadOneMDString(ID);
  if (!IsDistinct) {
    if (auto *MD = MetadataList.lookup(ID))
      return MD;
    // If lazy-loading is enabled, we try recursively to load the operand
    // instead of creating a temporary.
    if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
      // Create a temporary for the node that is referencing the operand we
      // will lazy-load. It is needed before recursing in case there are
      // uniquing cycles.
      MetadataList.getMetadataFwdRef(NextMetadataNo);
      lazyLoadOneMetadata(ID, Placeholders);
      return MetadataList.lookup(ID);
    }
    // Return a temporary.
    return MetadataList.getMetadataFwdRef(ID);
  }
  if (auto *MD = MetadataList.getMetadataIfResolved(ID))
    return MD;
  return &Placeholders.getPlaceholderOp(ID);
};
auto getMDOrNull = [&](unsigned ID) -> Metadata * {
  if (ID)
    return getMD(ID - 1);
  return nullptr;
};
auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
  if (ID)
    return MetadataList.getMetadataFwdRef(ID - 1);
  return nullptr;
};
auto getMDString = [&](unsigned ID) -> MDString * {
  // This requires that the ID is not really a forward reference.  In
  // particular, the MDString must already have been resolved.
  auto MDS = getMDOrNull(ID);
  return cast_or_null<MDString>(MDS);
};

// Support for old type refs.
auto getDITypeRefOrNull = [&](unsigned ID) {
  return MetadataList.upgradeTypeRef(getMDOrNull(ID));
};

1173#define GET_OR_DISTINCT(CLASS, ARGS)                                           \
(IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)

switch (Code) {
default: // Default behavior: ignore.
  break;
case bitc::METADATA_NAME: {
  // Read name of the named metadata.
  SmallString<8> Name(Record.begin(), Record.end());
  Record.clear();
  if (Error E = Stream.ReadCode().moveInto(Code))
    return E;

  ++NumMDRecordLoaded;
  if (Expected<unsigned> MaybeNextBitCode = Stream.readRecord(Code, Record)) {
    if (MaybeNextBitCode.get() != bitc::METADATA_NAMED_NODE)
      return error("METADATA_NAME not followed by METADATA_NAMED_NODE");
  } else
    return MaybeNextBitCode.takeError();

  // Read named metadata elements.
  unsigned Size = Record.size();
  NamedMDNode *NMD = TheModule.getOrInsertNamedMetadata(Name);
  for (unsigned i = 0; i != Size; ++i) {
    MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[i]);
    if (!MD)
      return error("Invalid named metadata: expect fwd ref to MDNode");
    NMD->addOperand(MD);
  }
  break;
}
case bitc::METADATA_OLD_FN_NODE: {
  // Deprecated, but still needed to read old bitcode files.
  // This is a LocalAsMetadata record, the only type of function-local
  // metadata.
  if (Record.size() % 2 == 1)
    return error("Invalid record");

  // If this isn't a LocalAsMetadata record, we're dropping it.  This used
  // to be legal, but there's no upgrade path.
  auto dropRecord = [&] {
    MetadataList.assignValue(MDNode::get(Context, None), NextMetadataNo);
    NextMetadataNo++;
  };
  if (Record.size() != 2) {
    dropRecord();
    break;
  }

  unsigned TyID = Record[0];
  Type *Ty = getTypeByID(TyID);
  if (Ty->isMetadataTy() || Ty->isVoidTy()) {
    dropRecord();
    break;
  }

  MetadataList.assignValue(
      LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty, TyID)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_OLD_NODE: {
  // Deprecated, but still needed to read old bitcode files.
  if (Record.size() % 2 == 1)
    return error("Invalid record");

  unsigned Size = Record.size();
  SmallVector<Metadata *, 8> Elts;
  for (unsigned i = 0; i != Size; i += 2) {
    unsigned TyID = Record[i];
    Type *Ty = getTypeByID(TyID);
    if (!Ty)
      return error("Invalid record");
    if (Ty->isMetadataTy())
      Elts.push_back(getMD(Record[i + 1]));
    else if (!Ty->isVoidTy()) {
      auto *MD = ValueAsMetadata::get(
          ValueList.getValueFwdRef(Record[i + 1], Ty, TyID));
      assert(isa<ConstantAsMetadata>(MD) &&(static_cast <bool> (isa<ConstantAsMetadata>(MD) &&
 "Expected non-function-local metadata") ? void (0) : __assert_fail
 ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 1253, __extension__
 __PRETTY_FUNCTION__))
             "Expected non-function-local metadata")(static_cast <bool> (isa<ConstantAsMetadata>(MD) &&
 "Expected non-function-local metadata") ? void (0) : __assert_fail
 ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 1253, __extension__
 __PRETTY_FUNCTION__));
      Elts.push_back(MD);
    } else
      Elts.push_back(nullptr);
  }
  MetadataList.assignValue(MDNode::get(Context, Elts), NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_VALUE: {
  if (Record.size() != 2)
    return error("Invalid record");

  unsigned TyID = Record[0];
  Type *Ty = getTypeByID(TyID);
  if (Ty->isMetadataTy() || Ty->isVoidTy())
    return error("Invalid record");

  MetadataList.assignValue(
      ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty, TyID)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_DISTINCT_NODE:
  IsDistinct = true;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case bitc::METADATA_NODE: {
  SmallVector<Metadata *, 8> Elts;
  Elts.reserve(Record.size());
  for (unsigned ID : Record)
    Elts.push_back(getMDOrNull(ID));
  MetadataList.assignValue(IsDistinct ? MDNode::getDistinct(Context, Elts)
                                      : MDNode::get(Context, Elts),
                           NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_LOCATION: {
  if (Record.size() != 5 && Record.size() != 6)
    return error("Invalid record");

  IsDistinct = Record[0];
  unsigned Line = Record[1];
  unsigned Column = Record[2];
  Metadata *Scope = getMD(Record[3]);
  Metadata *InlinedAt = getMDOrNull(Record[4]);
  bool ImplicitCode = Record.size() == 6 && Record[5];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DILocation, (Context, Line, Column, Scope, InlinedAt,
                                   ImplicitCode)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_GENERIC_DEBUG: {
  if (Record.size() < 4)
    return error("Invalid record");

  IsDistinct = Record[0];
  unsigned Tag = Record[1];
  unsigned Version = Record[2];

  if (Tag >= 1u << 16 || Version != 0)
    return error("Invalid record");

  auto *Header = getMDString(Record[3]);
  SmallVector<Metadata *, 8> DwarfOps;
  for (unsigned I = 4, E = Record.size(); I != E; ++I)
    DwarfOps.push_back(getMDOrNull(Record[I]));
  MetadataList.assignValue(
      GET_OR_DISTINCT(GenericDINode, (Context, Tag, Header, DwarfOps)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_SUBRANGE: {
  Metadata *Val = nullptr;
  // Operand 'count' is interpreted as:
  // - Signed integer (version 0)
  // - Metadata node  (version 1)
  // Operand 'lowerBound' is interpreted as:
  // - Signed integer (version 0 and 1)
  // - Metadata node  (version 2)
  // Operands 'upperBound' and 'stride' are interpreted as:
  // - Metadata node  (version 2)
  switch (Record[0] >> 1) {
  case 0:
    Val = GET_OR_DISTINCT(DISubrange,
                          (Context, Record[1], unrotateSign(Record[2])));
    break;
  case 1:
    Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
                                       unrotateSign(Record[2])));
    break;
  case 2:
    Val = GET_OR_DISTINCT(
        DISubrange, (Context, getMDOrNull(Record[1]), getMDOrNull(Record[2]),
                     getMDOrNull(Record[3]), getMDOrNull(Record[4])));
    break;
  default:
    return error("Invalid record: Unsupported version of DISubrange");
  }

  MetadataList.assignValue(Val, NextMetadataNo);
  IsDistinct = Record[0] & 1;
  NextMetadataNo++;
  break;
}
case bitc::METADATA_GENERIC_SUBRANGE: {
  Metadata *Val = nullptr;
  Val = GET_OR_DISTINCT(DIGenericSubrange,
                        (Context, getMDOrNull(Record[1]),
                         getMDOrNull(Record[2]), getMDOrNull(Record[3]),
                         getMDOrNull(Record[4])));

  MetadataList.assignValue(Val, NextMetadataNo);
  IsDistinct = Record[0] & 1;
  NextMetadataNo++;
  break;
}
case bitc::METADATA_ENUMERATOR: {
  if (Record.size() < 3)
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  bool IsUnsigned = Record[0] & 2;
  bool IsBigInt = Record[0] & 4;
  APInt Value;

  if (IsBigInt) {
    const uint64_t BitWidth = Record[1];
    const size_t NumWords = Record.size() - 3;
    Value = readWideAPInt(makeArrayRef(&Record[3], NumWords), BitWidth);
  } else
    Value = APInt(64, unrotateSign(Record[1]), !IsUnsigned);

  MetadataList.assignValue(
      GET_OR_DISTINCT(DIEnumerator,
                      (Context, Value, IsUnsigned, getMDString(Record[2]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_BASIC_TYPE: {
  if (Record.size() < 6 || Record.size() > 7)
    return error("Invalid record");

  IsDistinct = Record[0];
  DINode::DIFlags Flags = (Record.size() > 6)
                              ? static_cast<DINode::DIFlags>(Record[6])
                              : DINode::FlagZero;

  MetadataList.assignValue(
      GET_OR_DISTINCT(DIBasicType,
                      (Context, Record[1], getMDString(Record[2]), Record[3],
                       Record[4], Record[5], Flags)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_STRING_TYPE: {
  if (Record.size() > 9 || Record.size() < 8)
    return error("Invalid record");

  IsDistinct = Record[0];
  bool SizeIs8 = Record.size() == 8;
  // StringLocationExp (i.e. Record[5]) is added at a later time
  // than the other fields. The code here enables backward compatibility.
  Metadata *StringLocationExp = SizeIs8 ? nullptr : getMDOrNull(Record[5]);
  unsigned Offset = SizeIs8 ? 5 : 6;
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIStringType,
                      (Context, Record[1], getMDString(Record[2]),
                       getMDOrNull(Record[3]), getMDOrNull(Record[4]),
                       StringLocationExp, Record[Offset], Record[Offset + 1],
                       Record[Offset + 2])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_DERIVED_TYPE: {
  if (Record.size() < 12 || Record.size() > 14)
    return error("Invalid record");

  // DWARF address space is encoded as N->getDWARFAddressSpace() + 1. 0 means
  // that there is no DWARF address space associated with DIDerivedType.
  Optional<unsigned> DWARFAddressSpace;
  if (Record.size() > 12 && Record[12])
    DWARFAddressSpace = Record[12] - 1;

  Metadata *Annotations = nullptr;
  if (Record.size() > 13 && Record[13])
    Annotations = getMDOrNull(Record[13]);

  IsDistinct = Record[0];
  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIDerivedType,
                      (Context, Record[1], getMDString(Record[2]),
                       getMDOrNull(Record[3]), Record[4],
                       getDITypeRefOrNull(Record[5]),
                       getDITypeRefOrNull(Record[6]), Record[7], Record[8],
                       Record[9], DWARFAddressSpace, Flags,
                       getDITypeRefOrNull(Record[11]), Annotations)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_COMPOSITE_TYPE: {
  if (Record.size() < 16 || Record.size() > 22)
    return error("Invalid record");

  // If we have a UUID and this is not a forward declaration, lookup the
  // mapping.
  IsDistinct = Record[0] & 0x1;
  bool IsNotUsedInTypeRef = Record[0] >= 2;
  unsigned Tag = Record[1];
  MDString *Name = getMDString(Record[2]);
  Metadata *File = getMDOrNull(Record[3]);
  unsigned Line = Record[4];
  Metadata *Scope = getDITypeRefOrNull(Record[5]);
  Metadata *BaseType = nullptr;
  uint64_t SizeInBits = Record[7];
  if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
    return error("Alignment value is too large");
  uint32_t AlignInBits = Record[8];
  uint64_t OffsetInBits = 0;
  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
  Metadata *Elements = nullptr;
  unsigned RuntimeLang = Record[12];
  Metadata *VTableHolder = nullptr;
  Metadata *TemplateParams = nullptr;
  Metadata *Discriminator = nullptr;
  Metadata *DataLocation = nullptr;
  Metadata *Associated = nullptr;
  Metadata *Allocated = nullptr;
  Metadata *Rank = nullptr;
  Metadata *Annotations = nullptr;
  auto *Identifier = getMDString(Record[15]);
  // If this module is being parsed so that it can be ThinLTO imported
  // into another module, composite types only need to be imported
  // as type declarations (unless full type definitions requested).
  // Create type declarations up front to save memory. Also, buildODRType
  // handles the case where this is type ODRed with a definition needed
  // by the importing module, in which case the existing definition is
  // used.
  if (IsImporting && !ImportFullTypeDefinitions && Identifier &&
      (Tag == dwarf::DW_TAG_enumeration_type ||
       Tag == dwarf::DW_TAG_class_type ||
       Tag == dwarf::DW_TAG_structure_type ||
       Tag == dwarf::DW_TAG_union_type)) {
    Flags = Flags | DINode::FlagFwdDecl;
    if (Name) {
      // This is a hack around preserving template parameters for simplified
      // template names - it should probably be replaced with a
      // DICompositeType flag specifying whether template parameters are
      // required on declarations of this type.
      StringRef NameStr = Name->getString();
      if (!NameStr.contains('<') || NameStr.startswith("_STN|"))
        TemplateParams = getMDOrNull(Record[14]);
    }
  } else {
    BaseType = getDITypeRefOrNull(Record[6]);
    OffsetInBits = Record[9];
    Elements = getMDOrNull(Record[11]);
    VTableHolder = getDITypeRefOrNull(Record[13]);
    TemplateParams = getMDOrNull(Record[14]);
    if (Record.size() > 16)
      Discriminator = getMDOrNull(Record[16]);
    if (Record.size() > 17)
      DataLocation = getMDOrNull(Record[17]);
    if (Record.size() > 19) {
      Associated = getMDOrNull(Record[18]);
      Allocated = getMDOrNull(Record[19]);
    }
    if (Record.size() > 20) {
      Rank = getMDOrNull(Record[20]);
    }
    if (Record.size() > 21) {
      Annotations = getMDOrNull(Record[21]);
    }
  }
  DICompositeType *CT = nullptr;
  if (Identifier)
    CT = DICompositeType::buildODRType(
        Context, *Identifier, Tag, Name, File, Line, Scope, BaseType,
        SizeInBits, AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
        VTableHolder, TemplateParams, Discriminator, DataLocation, Associated,
        Allocated, Rank, Annotations);

  // Create a node if we didn't get a lazy ODR type.
  if (!CT)
    CT = GET_OR_DISTINCT(DICompositeType,
                         (Context, Tag, Name, File, Line, Scope, BaseType,
                          SizeInBits, AlignInBits, OffsetInBits, Flags,
                          Elements, RuntimeLang, VTableHolder, TemplateParams,
                          Identifier, Discriminator, DataLocation, Associated,
                          Allocated, Rank, Annotations));
  if (!IsNotUsedInTypeRef && Identifier)
    MetadataList.addTypeRef(*Identifier, *cast<DICompositeType>(CT));

  MetadataList.assignValue(CT, NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_SUBROUTINE_TYPE: {
  if (Record.size() < 3 || Record.size() > 4)
    return error("Invalid record");
  bool IsOldTypeRefArray = Record[0] < 2;
  unsigned CC = (Record.size() > 3) ? Record[3] : 0;

  IsDistinct = Record[0] & 0x1;
  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
  Metadata *Types = getMDOrNull(Record[2]);
  if (LLVM_UNLIKELY(IsOldTypeRefArray)__builtin_expect((bool)(IsOldTypeRefArray), false))
    Types = MetadataList.upgradeTypeRefArray(Types);

  MetadataList.assignValue(
      GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}

case bitc::METADATA_MODULE: {
  if (Record.size() < 5 || Record.size() > 9)
    return error("Invalid record");

  unsigned Offset = Record.size() >= 8 ? 2 : 1;
  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(
          DIModule,
          (Context, Record.size() >= 8 ? getMDOrNull(Record[1]) : nullptr,
           getMDOrNull(Record[0 + Offset]), getMDString(Record[1 + Offset]),
           getMDString(Record[2 + Offset]), getMDString(Record[3 + Offset]),
           getMDString(Record[4 + Offset]),
           Record.size() <= 7 ? 0 : Record[7],
           Record.size() <= 8 ? false : Record[8])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}

case bitc::METADATA_FILE: {
  if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
    return error("Invalid record");

  IsDistinct = Record[0];
  Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
  // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
  // is not present. This matches up with the old internal representation,
  // and the old encoding for CSK_None in the ChecksumKind. The new
  // representation reserves the value 0 in the ChecksumKind to continue to
  // encode None in a backwards-compatible way.
  if (Record.size() > 4 && Record[3] && Record[4])
    Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
                     getMDString(Record[4]));
  MetadataList.assignValue(
      GET_OR_DISTINCT(
          DIFile,
          (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
           Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
                             : None)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_COMPILE_UNIT: {
  if (Record.size() < 14 || Record.size() > 22)
    return error("Invalid record");

  // Ignore Record[0], which indicates whether this compile unit is
  // distinct.  It's always distinct.
  IsDistinct = true;
  auto *CU = DICompileUnit::getDistinct(
      Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
      Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
      Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
      getMDOrNull(Record[12]), getMDOrNull(Record[13]),
      Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
      Record.size() <= 14 ? 0 : Record[14],
      Record.size() <= 16 ? true : Record[16],
      Record.size() <= 17 ? false : Record[17],
      Record.size() <= 18 ? 0 : Record[18],
      Record.size() <= 19 ? false : Record[19],
      Record.size() <= 20 ? nullptr : getMDString(Record[20]),
      Record.size() <= 21 ? nullptr : getMDString(Record[21]));

  MetadataList.assignValue(CU, NextMetadataNo);
  NextMetadataNo++;

  // Move the Upgrade the list of subprograms.
  if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
    CUSubprograms.push_back({CU, SPs});
  break;
}
case bitc::METADATA_SUBPROGRAM: {
  if (Record.size() < 18 || Record.size() > 21)
    return error("Invalid record");

  bool HasSPFlags = Record[0] & 4;

  DINode::DIFlags Flags;
  DISubprogram::DISPFlags SPFlags;
  if (!HasSPFlags)
    Flags = static_cast<DINode::DIFlags>(Record[11 + 2]);
  else {
    Flags = static_cast<DINode::DIFlags>(Record[11]);
    SPFlags = static_cast<DISubprogram::DISPFlags>(Record[9]);
  }

  // Support for old metadata when
  // subprogram specific flags are placed in DIFlags.
  const unsigned DIFlagMainSubprogram = 1 << 21;
  bool HasOldMainSubprogramFlag = Flags & DIFlagMainSubprogram;
  if (HasOldMainSubprogramFlag)
    // Remove old DIFlagMainSubprogram from DIFlags.
    // Note: This assumes that any future use of bit 21 defaults to it
    // being 0.
    Flags &= ~static_cast<DINode::DIFlags>(DIFlagMainSubprogram);

  if (HasOldMainSubprogramFlag && HasSPFlags)
    SPFlags |= DISubprogram::SPFlagMainSubprogram;
  else if (!HasSPFlags)
    SPFlags = DISubprogram::toSPFlags(
        /*IsLocalToUnit=*/Record[7], /*IsDefinition=*/Record[8],
        /*IsOptimized=*/Record[14], /*Virtuality=*/Record[11],
        /*IsMainSubprogram=*/HasOldMainSubprogramFlag);

  // All definitions should be distinct.
  IsDistinct = (Record[0] & 1) || (SPFlags & DISubprogram::SPFlagDefinition);
  // Version 1 has a Function as Record[15].
  // Version 2 has removed Record[15].
  // Version 3 has the Unit as Record[15].
  // Version 4 added thisAdjustment.
  // Version 5 repacked flags into DISPFlags, changing many element numbers.
  bool HasUnit = Record[0] & 2;
  if (!HasSPFlags && HasUnit && Record.size() < 19)
    return error("Invalid record");
  if (HasSPFlags && !HasUnit)
    return error("Invalid record");
  // Accommodate older formats.
  bool HasFn = false;
  bool HasThisAdj = true;
  bool HasThrownTypes = true;
  bool HasAnnotations = false;
  bool HasTargetFuncName = false;
  unsigned OffsetA = 0;
  unsigned OffsetB = 0;
  if (!HasSPFlags) {
    OffsetA = 2;
    OffsetB = 2;
    if (Record.size() >= 19) {
      HasFn = !HasUnit;
      OffsetB++;
    }
    HasThisAdj = Record.size() >= 20;
    HasThrownTypes = Record.size() >= 21;
  } else {
    HasAnnotations = Record.size() >= 19;
    HasTargetFuncName = Record.size() >= 20;
  }
  Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
  DISubprogram *SP = GET_OR_DISTINCT(
      DISubprogram,
      (Context,
       getDITypeRefOrNull(Record[1]),           // scope
       getMDString(Record[2]),                  // name
       getMDString(Record[3]),                  // linkageName
       getMDOrNull(Record[4]),                  // file
       Record[5],                               // line
       getMDOrNull(Record[6]),                  // type
       Record[7 + OffsetA],                     // scopeLine
       getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
       Record[10 + OffsetA],                    // virtualIndex
       HasThisAdj ? Record[16 + OffsetB] : 0,   // thisAdjustment
       Flags,                                   // flags
       SPFlags,                                 // SPFlags
       HasUnit ? CUorFn : nullptr,              // unit
       getMDOrNull(Record[13 + OffsetB]),       // templateParams
       getMDOrNull(Record[14 + OffsetB]),       // declaration
       getMDOrNull(Record[15 + OffsetB]),       // retainedNodes
       HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
                      : nullptr, // thrownTypes
       HasAnnotations ? getMDOrNull(Record[18 + OffsetB])
                      : nullptr, // annotations
       HasTargetFuncName ? getMDString(Record[19 + OffsetB])
                         : nullptr // targetFuncName
       ));
  MetadataList.assignValue(SP, NextMetadataNo);
  NextMetadataNo++;

  // Upgrade sp->function mapping to function->sp mapping.
  if (HasFn) {
    if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(CUorFn))
      if (auto *F = dyn_cast<Function>(CMD->getValue())) {
        if (F->isMaterializable())
          // Defer until materialized; unmaterialized functions may not have
          // metadata.
          FunctionsWithSPs[F] = SP;
        else if (!F->empty())
          F->setSubprogram(SP);
      }
  }
  break;
}
case bitc::METADATA_LEXICAL_BLOCK: {
  if (Record.size() != 5)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DILexicalBlock,
                      (Context, getMDOrNull(Record[1]),
                       getMDOrNull(Record[2]), Record[3], Record[4])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_LEXICAL_BLOCK_FILE: {
  if (Record.size() != 4)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DILexicalBlockFile,
                      (Context, getMDOrNull(Record[1]),
                       getMDOrNull(Record[2]), Record[3])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_COMMON_BLOCK: {
  IsDistinct = Record[0] & 1;
  MetadataList.assignValue(
      GET_OR_DISTINCT(DICommonBlock,
                      (Context, getMDOrNull(Record[1]),
                       getMDOrNull(Record[2]), getMDString(Record[3]),
                       getMDOrNull(Record[4]), Record[5])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_NAMESPACE: {
  // Newer versions of DINamespace dropped file and line.
  MDString *Name;
  if (Record.size() == 3)
    Name = getMDString(Record[2]);
  else if (Record.size() == 5)
    Name = getMDString(Record[3]);
  else
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  bool ExportSymbols = Record[0] & 2;
  MetadataList.assignValue(
      GET_OR_DISTINCT(DINamespace,
                      (Context, getMDOrNull(Record[1]), Name, ExportSymbols)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_MACRO: {
  if (Record.size() != 5)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIMacro,
                      (Context, Record[1], Record[2], getMDString(Record[3]),
                       getMDString(Record[4]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_MACRO_FILE: {
  if (Record.size() != 5)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIMacroFile,
                      (Context, Record[1], Record[2], getMDOrNull(Record[3]),
                       getMDOrNull(Record[4]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_TEMPLATE_TYPE: {
  if (Record.size() < 3 || Record.size() > 4)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DITemplateTypeParameter,
                      (Context, getMDString(Record[1]),
                       getDITypeRefOrNull(Record[2]),
                       (Record.size() == 4) ? getMDOrNull(Record[3])
                                            : getMDOrNull(false))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_TEMPLATE_VALUE: {
  if (Record.size() < 5 || Record.size() > 6)
    return error("Invalid record");

  IsDistinct = Record[0];

  MetadataList.assignValue(
      GET_OR_DISTINCT(
          DITemplateValueParameter,
          (Context, Record[1], getMDString(Record[2]),
           getDITypeRefOrNull(Record[3]),
           (Record.size() == 6) ? getMDOrNull(Record[4]) : getMDOrNull(false),
           (Record.size() == 6) ? getMDOrNull(Record[5])
                                : getMDOrNull(Record[4]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_GLOBAL_VAR: {
  if (Record.size() < 11 || Record.size() > 13)
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  unsigned Version = Record[0] >> 1;

  if (Version == 2) {
    Metadata *Annotations = nullptr;
    if (Record.size() > 12)
      Annotations = getMDOrNull(Record[12]);

    MetadataList.assignValue(
        GET_OR_DISTINCT(DIGlobalVariable,
                        (Context, getMDOrNull(Record[1]),
                         getMDString(Record[2]), getMDString(Record[3]),
                         getMDOrNull(Record[4]), Record[5],
                         getDITypeRefOrNull(Record[6]), Record[7], Record[8],
                         getMDOrNull(Record[9]), getMDOrNull(Record[10]),
                         Record[11], Annotations)),
        NextMetadataNo);

    NextMetadataNo++;
  } else if (Version == 1) {
    // No upgrade necessary. A null field will be introduced to indicate
    // that no parameter information is available.
    MetadataList.assignValue(
        GET_OR_DISTINCT(
            DIGlobalVariable,
            (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
             getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
             getDITypeRefOrNull(Record[6]), Record[7], Record[8],
             getMDOrNull(Record[10]), nullptr, Record[11], nullptr)),
        NextMetadataNo);

    NextMetadataNo++;
  } else if (Version == 0) {
    // Upgrade old metadata, which stored a global variable reference or a
    // ConstantInt here.
    NeedUpgradeToDIGlobalVariableExpression = true;
    Metadata *Expr = getMDOrNull(Record[9]);
    uint32_t AlignInBits = 0;
    if (Record.size() > 11) {
      if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
        return error("Alignment value is too large");
      AlignInBits = Record[11];
    }
    GlobalVariable *Attach = nullptr;
    if (auto *CMD = dyn_cast_or_null<ConstantAsMetadata>(Expr)) {
      if (auto *GV = dyn_cast<GlobalVariable>(CMD->getValue())) {
        Attach = GV;
        Expr = nullptr;
      } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
        Expr = DIExpression::get(Context,
                                 {dwarf::DW_OP_constu, CI->getZExtValue(),
                                  dwarf::DW_OP_stack_value});
      } else {
        Expr = nullptr;
      }
    }
    DIGlobalVariable *DGV = GET_OR_DISTINCT(
        DIGlobalVariable,
        (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
         getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
         getDITypeRefOrNull(Record[6]), Record[7], Record[8],
         getMDOrNull(Record[10]), nullptr, AlignInBits, nullptr));

    DIGlobalVariableExpression *DGVE = nullptr;
    if (Attach || Expr)
      DGVE = DIGlobalVariableExpression::getDistinct(
          Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
    if (Attach)
      Attach->addDebugInfo(DGVE);

    auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
    MetadataList.assignValue(MDNode, NextMetadataNo);
    NextMetadataNo++;
  } else
    return error("Invalid record");

  break;
}
case bitc::METADATA_LOCAL_VAR: {
  // 10th field is for the obseleted 'inlinedAt:' field.
  if (Record.size() < 8 || Record.size() > 10)
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  bool HasAlignment = Record[0] & 2;
  // 2nd field used to be an artificial tag, either DW_TAG_auto_variable or
  // DW_TAG_arg_variable, if we have alignment flag encoded it means, that
  // this is newer version of record which doesn't have artificial tag.
  bool HasTag = !HasAlignment && Record.size() > 8;
  DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[7 + HasTag]);
  uint32_t AlignInBits = 0;
  Metadata *Annotations = nullptr;
  if (HasAlignment) {
    if (Record[8] > (uint64_t)std::numeric_limits<uint32_t>::max())
      return error("Alignment value is too large");
    AlignInBits = Record[8];
    if (Record.size() > 9)
      Annotations = getMDOrNull(Record[9]);
  }

  MetadataList.assignValue(
      GET_OR_DISTINCT(DILocalVariable,
                      (Context, getMDOrNull(Record[1 + HasTag]),
                       getMDString(Record[2 + HasTag]),
                       getMDOrNull(Record[3 + HasTag]), Record[4 + HasTag],
                       getDITypeRefOrNull(Record[5 + HasTag]),
                       Record[6 + HasTag], Flags, AlignInBits, Annotations)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_LABEL: {
  if (Record.size() != 5)
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  MetadataList.assignValue(
      GET_OR_DISTINCT(DILabel, (Context, getMDOrNull(Record[1]),
                                getMDString(Record[2]),
                                getMDOrNull(Record[3]), Record[4])),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_EXPRESSION: {
  if (Record.size() < 1)
    return error("Invalid record");

  IsDistinct = Record[0] & 1;
  uint64_t Version = Record[0] >> 1;
  auto Elts = MutableArrayRef<uint64_t>(Record).slice(1);

  SmallVector<uint64_t, 6> Buffer;
  if (Error Err = upgradeDIExpression(Version, Elts, Buffer))
    return Err;

  MetadataList.assignValue(GET_OR_DISTINCT(DIExpression, (Context, Elts)),
                           NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_GLOBAL_VAR_EXPR: {
  if (Record.size() != 3)
    return error("Invalid record");

  IsDistinct = Record[0];
  Metadata *Expr = getMDOrNull(Record[2]);
  if (!Expr)
    Expr = DIExpression::get(Context, {});
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIGlobalVariableExpression,
                      (Context, getMDOrNull(Record[1]), Expr)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_OBJC_PROPERTY: {
  if (Record.size() != 8)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIObjCProperty,
                      (Context, getMDString(Record[1]),
                       getMDOrNull(Record[2]), Record[3],
                       getMDString(Record[4]), getMDString(Record[5]),
                       Record[6], getDITypeRefOrNull(Record[7]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_IMPORTED_ENTITY: {
  if (Record.size() < 6 || Record.size() > 8)
    return error("Invalid DIImportedEntity record");

  IsDistinct = Record[0];
  bool HasFile = (Record.size() >= 7);
  bool HasElements = (Record.size() >= 8);
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIImportedEntity,
                      (Context, Record[1], getMDOrNull(Record[2]),
                       getDITypeRefOrNull(Record[3]),
                       HasFile ? getMDOrNull(Record[6]) : nullptr,
                       HasFile ? Record[4] : 0, getMDString(Record[5]),
                       HasElements ? getMDOrNull(Record[7]) : nullptr)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_STRING_OLD: {
  std::string String(Record.begin(), Record.end());

  // Test for upgrading !llvm.loop.
  HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
  ++NumMDStringLoaded;
  Metadata *MD = MDString::get(Context, String);
  MetadataList.assignValue(MD, NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_STRINGS: {
  auto CreateNextMDString = [&](StringRef Str) {
    ++NumMDStringLoaded;
    MetadataList.assignValue(MDString::get(Context, Str), NextMetadataNo);
    NextMetadataNo++;
  };
  if (Error Err = parseMetadataStrings(Record, Blob, CreateNextMDString))
    return Err;
  break;
}
case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
  if (Record.size() % 2 == 0)
    return error("Invalid record");
  unsigned ValueID = Record[0];
  if (ValueID >= ValueList.size())
    return error("Invalid record");
  if (auto *GO = dyn_cast<GlobalObject>(ValueList[ValueID]))
    if (Error Err = parseGlobalObjectAttachment(
            *GO, ArrayRef<uint64_t>(Record).slice(1)))
      return Err;
  break;
}
case bitc::METADATA_KIND: {
  // Support older bitcode files that had METADATA_KIND records in a
  // block with METADATA_BLOCK_ID.
  if (Error Err = parseMetadataKindRecord(Record))
    return Err;
  break;
}
case bitc::METADATA_ARG_LIST: {
  SmallVector<ValueAsMetadata *, 4> Elts;
  Elts.reserve(Record.size());
  for (uint64_t Elt : Record) {
    Metadata *MD = getMD(Elt);
    if (isa<MDNode>(MD) && cast<MDNode>(MD)->isTemporary())
      return error(
          "Invalid record: DIArgList should not contain forward refs");
    if (!isa<ValueAsMetadata>(MD))
      return error("Invalid record");
    Elts.push_back(cast<ValueAsMetadata>(MD));
  }

  MetadataList.assignValue(DIArgList::get(Context, Elts), NextMetadataNo);
  NextMetadataNo++;
  break;
}
}
return Error::success();
2128#undef GET_OR_DISTINCT
2129}

2131Error MetadataLoader::MetadataLoaderImpl::parseMetadataStrings(
  ArrayRef<uint64_t> Record, StringRef Blob,
  function_ref<void(StringRef)> CallBack) {
// All the MDStrings in the block are emitted together in a single
// record.  The strings are concatenated and stored in a blob along with
// their sizes.
if (Record.size() != 2)
  return error("Invalid record: metadata strings layout");

unsigned NumStrings = Record[0];
unsigned StringsOffset = Record[1];
if (!NumStrings)
  return error("Invalid record: metadata strings with no strings");
if (StringsOffset > Blob.size())
  return error("Invalid record: metadata strings corrupt offset");

StringRef Lengths = Blob.slice(0, StringsOffset);
SimpleBitstreamCursor R(Lengths);

StringRef Strings = Blob.drop_front(StringsOffset);
do {
  if (R.AtEndOfStream())
    return error("Invalid record: metadata strings bad length");

  uint32_t Size;
  if (Error E = R.ReadVBR(6).moveInto(Size))
    return E;
  if (Strings.size() < Size)
    return error("Invalid record: metadata strings truncated chars");

  CallBack(Strings.slice(0, Size));
  Strings = Strings.drop_front(Size);
} while (--NumStrings);

return Error::success();
2166}

2168Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
  GlobalObject &GO, ArrayRef<uint64_t> Record) {
assert(Record.size() % 2 == 0)(static_cast <bool> (Record.size() % 2 == 0) ? void (0)
 : __assert_fail ("Record.size() % 2 == 0", "llvm/lib/Bitcode/Reader/MetadataLoader.cpp"
, 2170, __extension__ __PRETTY_FUNCTION__));
14
←
Assuming the condition is true→
15
←
'?' condition is true→
for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
16
←
Assuming 'I' is not equal to 'E'→
17
←
Loop condition is true.  Entering loop body→
  auto K = MDKindMap.find(Record[I]);
  if (K == MDKindMap.end())
18
←
Taking false branch→
    return error("Invalid ID");
  MDNode *MD =
      dyn_cast_or_null<MDNode>(getMetadataFwdRefOrLoad(Record[I + 1]));
19
←
Calling 'MetadataLoaderImpl::getMetadataFwdRefOrLoad'→
  if (!MD)
    return error("Invalid metadata attachment: expect fwd ref to MDNode");
  GO.addMetadata(K->second, *MD);
}
return Error::success();
2182}

2184/// Parse metadata attachments.
2185Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
  Function &F, ArrayRef<Instruction *> InstructionList) {
if (Error Err = Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return Err;

SmallVector<uint64_t, 64> Record;
PlaceholderQueue Placeholders;

while (true) {
4
←
Loop condition is true.  Entering loop body→
  BitstreamEntry Entry;
  if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
5
←
Taking false branch→
    return E;

  switch (Entry.Kind) {
6
←
Control jumps to 'case Record:'  at line 2205→
  case BitstreamEntry::SubBlock: // Handled for us already.
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    resolveForwardRefsAndPlaceholders(Placeholders);
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
7
←
 Execution continues on line 2211→
  }

  // Read a metadata attachment record.
  Record.clear();
  ++NumMDRecordLoaded;
  Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
  if (!MaybeRecord)
8
←
Taking false branch→
    return MaybeRecord.takeError();
  switch (MaybeRecord.get()) {
9
←
Control jumps to 'case METADATA_ATTACHMENT:'  at line 2219→
  default: // Default behavior: ignore.
    break;
  case bitc::METADATA_ATTACHMENT: {
    unsigned RecordLength = Record.size();
    if (Record.empty())
10
←
Taking false branch→
      return error("Invalid record");
    if (RecordLength % 2 == 0) {
11
←
Assuming the condition is true→
12
←
Taking true branch→
      // A function attachment.
      if (Error Err = parseGlobalObjectAttachment(F, Record))
13
←
Calling 'MetadataLoaderImpl::parseGlobalObjectAttachment'→
        return Err;
      continue;
    }

    // An instruction attachment.
    Instruction *Inst = InstructionList[Record[0]];
    for (unsigned i = 1; i != RecordLength; i = i + 2) {
      unsigned Kind = Record[i];
      DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);
      if (I == MDKindMap.end())
        return error("Invalid ID");
      if (I->second == LLVMContext::MD_tbaa && StripTBAA)
        continue;

      auto Idx = Record[i + 1];
      if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
          !MetadataList.lookup(Idx)) {
        // Load the attachment if it is in the lazy-loadable range and hasn't
        // been loaded yet.
        lazyLoadOneMetadata(Idx, Placeholders);
        resolveForwardRefsAndPlaceholders(Placeholders);
      }

      Metadata *Node = MetadataList.getMetadataFwdRef(Idx);
      if (isa<LocalAsMetadata>(Node))
        // Drop the attachment.  This used to be legal, but there's no
        // upgrade path.
        break;
      MDNode *MD = dyn_cast_or_null<MDNode>(Node);
      if (!MD)
        return error("Invalid metadata attachment");

      if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
        MD = upgradeInstructionLoopAttachment(*MD);

      if (I->second == LLVMContext::MD_tbaa) {
        assert(!MD->isTemporary() && "should load MDs before attachments")(static_cast <bool> (!MD->isTemporary() && "should load MDs before attachments"
) ? void (0) : __assert_fail ("!MD->isTemporary() && \"should load MDs before attachments\""
, "llvm/lib/Bitcode/Reader/MetadataLoader.cpp", 2262, __extension__
 __PRETTY_FUNCTION__));
        MD = UpgradeTBAANode(*MD);
      }
      Inst->setMetadata(I->second, MD);
    }
    break;
  }
  }
}
2271}

2273/// Parse a single METADATA_KIND record, inserting result in MDKindMap.
2274Error MetadataLoader::MetadataLoaderImpl::parseMetadataKindRecord(
  SmallVectorImpl<uint64_t> &Record) {
if (Record.size() < 2)
  return error("Invalid record");

unsigned Kind = Record[0];
SmallString<8> Name(Record.begin() + 1, Record.end());

unsigned NewKind = TheModule.getMDKindID(Name.str());
if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second)
  return error("Conflicting METADATA_KIND records");
return Error::success();
2286}

2288/// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
2289Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
if (Error Err = Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
  return Err;

SmallVector<uint64_t, 64> Record;

// Read all the records.
while (true) {
  BitstreamEntry Entry;
  if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))
    return E;

  switch (Entry.Kind) {
  case BitstreamEntry::SubBlock: // Handled for us already.
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  ++NumMDRecordLoaded;
  Expected<unsigned> MaybeCode = Stream.readRecord(Entry.ID, Record);
  if (!MaybeCode)
    return MaybeCode.takeError();
  switch (MaybeCode.get()) {
  default: // Default behavior: ignore.
    break;
  case bitc::METADATA_KIND: {
    if (Error Err = parseMetadataKindRecord(Record))
      return Err;
    break;
  }
  }
}
2328}

2330MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
Pimpl = std::move(RHS.Pimpl);
return *this;
2333}
2334MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
  : Pimpl(std::move(RHS.Pimpl)) {}

2337MetadataLoader::~MetadataLoader() = default;
2338MetadataLoader::MetadataLoader(BitstreamCursor &Stream, Module &TheModule,
                             BitcodeReaderValueList &ValueList,
                             bool IsImporting,
                             std::function<Type *(unsigned)> getTypeByID)
  : Pimpl(std::make_unique<MetadataLoaderImpl>(
        Stream, TheModule, ValueList, std::move(getTypeByID), IsImporting)) {}

2345Error MetadataLoader::parseMetadata(bool ModuleLevel) {
return Pimpl->parseMetadata(ModuleLevel);
2347}

2349bool MetadataLoader::hasFwdRefs() const { return Pimpl->hasFwdRefs(); }

2351/// Return the given metadata, creating a replaceable forward reference if
2352/// necessary.
2353Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
return Pimpl->getMetadataFwdRefOrLoad(Idx);
2355}

2357DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
return Pimpl->lookupSubprogramForFunction(F);
2359}

2361Error MetadataLoader::parseMetadataAttachment(
  Function &F, ArrayRef<Instruction *> InstructionList) {
return Pimpl->parseMetadataAttachment(F, InstructionList);
1
Calling 'MetadataLoaderImpl::parseMetadataAttachment'→
2364}

2366Error MetadataLoader::parseMetadataKinds() {
return Pimpl->parseMetadataKinds();
2368}

2370void MetadataLoader::setStripTBAA(bool StripTBAA) {
return Pimpl->setStripTBAA(StripTBAA);
2372}

2374bool MetadataLoader::isStrippingTBAA() { return Pimpl->isStrippingTBAA(); }

2376unsigned MetadataLoader::size() const { return Pimpl->size(); }
2377void MetadataLoader::shrinkTo(unsigned N) { return Pimpl->shrinkTo(N); }

2379void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
return Pimpl->upgradeDebugIntrinsics(F);
2381}

←

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- 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// This file defines an API used to report recoverable errors.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_SUPPORT_ERROR_H
14#define LLVM_SUPPORT_ERROR_H
15 
16#include "llvm-c/Error.h"
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/StringExtras.h"
19#include "llvm/ADT/Twine.h"
20#include "llvm/Config/abi-breaking.h"
21#include "llvm/Support/AlignOf.h"
22#include "llvm/Support/Compiler.h"
23#include "llvm/Support/Debug.h"
24#include "llvm/Support/ErrorHandling.h"
25#include "llvm/Support/ErrorOr.h"
26#include "llvm/Support/Format.h"
27#include "llvm/Support/raw_ostream.h"
28#include <cassert>
29#include <cstdint>
30#include <cstdlib>
31#include <functional>
32#include <memory>
33#include <new>
34#include <string>
35#include <system_error>
36#include <type_traits>
37#include <utility>
38#include <vector>
39 
40namespace llvm {
41 
42class ErrorSuccess;
43 
44/// Base class for error info classes. Do not extend this directly: Extend
45/// the ErrorInfo template subclass instead.
46class ErrorInfoBase {
47public:
48  virtual ~ErrorInfoBase() = default;
49 
50  /// Print an error message to an output stream.
51  virtual void log(raw_ostream &OS) const = 0;
52 
53  /// Return the error message as a string.
54  virtual std::string message() const {
55    std::string Msg;
56    raw_string_ostream OS(Msg);
57    log(OS);
58    return OS.str();
59  }
60 
61  /// Convert this error to a std::error_code.
62  ///
63  /// This is a temporary crutch to enable interaction with code still
64  /// using std::error_code. It will be removed in the future.
65  virtual std::error_code convertToErrorCode() const = 0;
66 
67  // Returns the class ID for this type.
68  static const void *classID() { return &ID; }
69 
70  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
71  virtual const void *dynamicClassID() const = 0;
72 
73  // Check whether this instance is a subclass of the class identified by
74  // ClassID.
75  virtual bool isA(const void *const ClassID) const {
76    return ClassID == classID();
77  }
78 
79  // Check whether this instance is a subclass of ErrorInfoT.
80  template <typename ErrorInfoT> bool isA() const {
81    return isA(ErrorInfoT::classID());
82  }
83 
84private:
85  virtual void anchor();
86 
87  static char ID;
88};
89 
90/// Lightweight error class with error context and mandatory checking.
91///
92/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
93/// are represented by setting the pointer to a ErrorInfoBase subclass
94/// instance containing information describing the failure. Success is
95/// represented by a null pointer value.
96///
97/// Instances of Error also contains a 'Checked' flag, which must be set
98/// before the destructor is called, otherwise the destructor will trigger a
99/// runtime error. This enforces at runtime the requirement that all Error
100/// instances be checked or returned to the caller.
101///
102/// There are two ways to set the checked flag, depending on what state the
103/// Error instance is in. For Error instances indicating success, it
104/// is sufficient to invoke the boolean conversion operator. E.g.:
105///
106///   @code{.cpp}
107///   Error foo(<...>);
108///
109///   if (auto E = foo(<...>))
110///     return E; // <- Return E if it is in the error state.
111///   // We have verified that E was in the success state. It can now be safely
112///   // destroyed.
113///   @endcode
114///
115/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
116/// without testing the return value will raise a runtime error, even if foo
117/// returns success.
118///
119/// For Error instances representing failure, you must use either the
120/// handleErrors or handleAllErrors function with a typed handler. E.g.:
121///
122///   @code{.cpp}
123///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
124///     // Custom error info.
125///   };
126///
127///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
128///
129///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
130///   auto NewE =
131///     handleErrors(E,
132///       [](const MyErrorInfo &M) {
133///         // Deal with the error.
134///       },
135///       [](std::unique_ptr<OtherError> M) -> Error {
136///         if (canHandle(*M)) {
137///           // handle error.
138///           return Error::success();
139///         }
140///         // Couldn't handle this error instance. Pass it up the stack.
141///         return Error(std::move(M));
142///       );
143///   // Note - we must check or return NewE in case any of the handlers
144///   // returned a new error.
145///   @endcode
146///
147/// The handleAllErrors function is identical to handleErrors, except
148/// that it has a void return type, and requires all errors to be handled and
149/// no new errors be returned. It prevents errors (assuming they can all be
150/// handled) from having to be bubbled all the way to the top-level.
151///
152/// *All* Error instances must be checked before destruction, even if
153/// they're moved-assigned or constructed from Success values that have already
154/// been checked. This enforces checking through all levels of the call stack.
155class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
156  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
157  // to add to the error list. It can't rely on handleErrors for this, since
158  // handleErrors does not support ErrorList handlers.
159  friend class ErrorList;
160 
161  // handleErrors needs to be able to set the Checked flag.
162  template <typename... HandlerTs>
163  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
164 
165  // Expected<T> needs to be able to steal the payload when constructed from an
166  // error.
167  template <typename T> friend class Expected;
168 
169  // wrap needs to be able to steal the payload.
170  friend LLVMErrorRef wrap(Error);
171 
172protected:
173  /// Create a success value. Prefer using 'Error::success()' for readability
174  Error() {
175    setPtr(nullptr);
176    setChecked(false);
177  }
178 
179public:
180  /// Create a success value.
181  static ErrorSuccess success();
182 
183  // Errors are not copy-constructable.
184  Error(const Error &Other) = delete;
185 
186  /// Move-construct an error value. The newly constructed error is considered
187  /// unchecked, even if the source error had been checked. The original error
188  /// becomes a checked Success value, regardless of its original state.
189  Error(Error &&Other) {
190    setChecked(true);
191    *this = std::move(Other);
192  }
193 
194  /// Create an error value. Prefer using the 'make_error' function, but
195  /// this constructor can be useful when "re-throwing" errors from handlers.
196  Error(std::unique_ptr<ErrorInfoBase> Payload) {
197    setPtr(Payload.release());
198    setChecked(false);
199  }
200 
201  // Errors are not copy-assignable.
202  Error &operator=(const Error &Other) = delete;
203 
204  /// Move-assign an error value. The current error must represent success, you
205  /// you cannot overwrite an unhandled error. The current error is then
206  /// considered unchecked. The source error becomes a checked success value,
207  /// regardless of its original state.
208  Error &operator=(Error &&Other) {
209    // Don't allow overwriting of unchecked values.
210    assertIsChecked();
211    setPtr(Other.getPtr());
212 
213    // This Error is unchecked, even if the source error was checked.
214    setChecked(false);
215 
216    // Null out Other's payload and set its checked bit.
217    Other.setPtr(nullptr);
218    Other.setChecked(true);
219 
220    return *this;
221  }
222 
223  /// Destroy a Error. Fails with a call to abort() if the error is
224  /// unchecked.
225  ~Error() {
226    assertIsChecked();
227    delete getPtr();
228  }
229 
230  /// Bool conversion. Returns true if this Error is in a failure state,
231  /// and false if it is in an accept state. If the error is in a Success state
232  /// it will be considered checked.
233  explicit operator bool() {
234    setChecked(getPtr() == nullptr);
235    return getPtr() != nullptr;
236  }
237 
238  /// Check whether one error is a subclass of another.
239  template <typename ErrT> bool isA() const {
240    return getPtr() && getPtr()->isA(ErrT::classID());
241  }
242 
243  /// Returns the dynamic class id of this error, or null if this is a success
244  /// value.
245  const void* dynamicClassID() const {
246    if (!getPtr())
247      return nullptr;
248    return getPtr()->dynamicClassID();
249  }
250 
251private:
252#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
253  // assertIsChecked() happens very frequently, but under normal circumstances
254  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
255  // of debug prints can cause the function to be too large for inlining.  So
256  // it's important that we define this function out of line so that it can't be
257  // inlined.
258  [[noreturn]] void fatalUncheckedError() const;
259#endif
260 
261  void assertIsChecked() {
262#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
263    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
264      fatalUncheckedError();
265#endif
266  }
267 
268  ErrorInfoBase *getPtr() const {
269#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
270    return reinterpret_cast<ErrorInfoBase*>(
271             reinterpret_cast<uintptr_t>(Payload) &
272             ~static_cast<uintptr_t>(0x1));
273#else
274    return Payload;
275#endif
276  }
277 
278  void setPtr(ErrorInfoBase *EI) {
279#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
280    Payload = reinterpret_cast<ErrorInfoBase*>(
281                (reinterpret_cast<uintptr_t>(EI) &
282                 ~static_cast<uintptr_t>(0x1)) |
283                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
284#else
285    Payload = EI;
286#endif
287  }
288 
289  bool getChecked() const {
290#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
291    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
292#else
293    return true;
294#endif
295  }
296 
297  void setChecked(bool V) {
298#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
299    Payload = reinterpret_cast<ErrorInfoBase*>(
300                (reinterpret_cast<uintptr_t>(Payload) &
301                  ~static_cast<uintptr_t>(0x1)) |
302                  (V ? 0 : 1));
303#endif
304  }
305 
306  std::unique_ptr<ErrorInfoBase> takePayload() {
307    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
308    setPtr(nullptr);
309    setChecked(true);
310    return Tmp;
311  }
312 
313  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
314    if (auto *P = E.getPtr())
315      P->log(OS);
316    else
317      OS << "success";
318    return OS;
319  }
320 
321  ErrorInfoBase *Payload = nullptr;
322};
323 
324/// Subclass of Error for the sole purpose of identifying the success path in
325/// the type system. This allows to catch invalid conversion to Expected<T> at
326/// compile time.
327class ErrorSuccess final : public Error {};
328 
329inline ErrorSuccess Error::success() { return ErrorSuccess(); }
330 
331/// Make a Error instance representing failure using the given error info
332/// type.
333template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
334  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
335}
336 
337/// Base class for user error types. Users should declare their error types
338/// like:
339///
340/// class MyError : public ErrorInfo<MyError> {
341///   ....
342/// };
343///
344/// This class provides an implementation of the ErrorInfoBase::kind
345/// method, which is used by the Error RTTI system.
346template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
347class ErrorInfo : public ParentErrT {
348public:
349  using ParentErrT::ParentErrT; // inherit constructors
350 
351  static const void *classID() { return &ThisErrT::ID; }
352 
353  const void *dynamicClassID() const override { return &ThisErrT::ID; }
354 
355  bool isA(const void *const ClassID) const override {
356    return ClassID == classID() || ParentErrT::isA(ClassID);
357  }
358};
359 
360/// Special ErrorInfo subclass representing a list of ErrorInfos.
361/// Instances of this class are constructed by joinError.
362class ErrorList final : public ErrorInfo<ErrorList> {
363  // handleErrors needs to be able to iterate the payload list of an
364  // ErrorList.
365  template <typename... HandlerTs>
366  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
367 
368  // joinErrors is implemented in terms of join.
369  friend Error joinErrors(Error, Error);
370 
371public:
372  void log(raw_ostream &OS) const override {
373    OS << "Multiple errors:\n";
374    for (const auto &ErrPayload : Payloads) {
375      ErrPayload->log(OS);
376      OS << "\n";
377    }
378  }
379 
380  std::error_code convertToErrorCode() const override;
381 
382  // Used by ErrorInfo::classID.
383  static char ID;
384 
385private:
386  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
387            std::unique_ptr<ErrorInfoBase> Payload2) {
388    assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
 "ErrorList constructor payloads should be singleton errors")
 ? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "llvm/include/llvm/Support/Error.h", 389, __extension__ __PRETTY_FUNCTION__
))
389           "ErrorList constructor payloads should be singleton errors")(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
 "ErrorList constructor payloads should be singleton errors")
 ? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "llvm/include/llvm/Support/Error.h", 389, __extension__ __PRETTY_FUNCTION__
));
390    Payloads.push_back(std::move(Payload1));
391    Payloads.push_back(std::move(Payload2));
392  }
393 
394  static Error join(Error E1, Error E2) {
395    if (!E1)
396      return E2;
397    if (!E2)
398      return E1;
399    if (E1.isA<ErrorList>()) {
400      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
401      if (E2.isA<ErrorList>()) {
402        auto E2Payload = E2.takePayload();
403        auto &E2List = static_cast<ErrorList &>(*E2Payload);
404        for (auto &Payload : E2List.Payloads)
405          E1List.Payloads.push_back(std::move(Payload));
406      } else
407        E1List.Payloads.push_back(E2.takePayload());
408 
409      return E1;
410    }
411    if (E2.isA<ErrorList>()) {
412      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
413      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
414      return E2;
415    }
416    return Error(std::unique_ptr<ErrorList>(
417        new ErrorList(E1.takePayload(), E2.takePayload())));
418  }
419 
420  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
421};
422 
423/// Concatenate errors. The resulting Error is unchecked, and contains the
424/// ErrorInfo(s), if any, contained in E1, followed by the
425/// ErrorInfo(s), if any, contained in E2.
426inline Error joinErrors(Error E1, Error E2) {
427  return ErrorList::join(std::move(E1), std::move(E2));
428}
429 
430/// Tagged union holding either a T or a Error.
431///
432/// This class parallels ErrorOr, but replaces error_code with Error. Since
433/// Error cannot be copied, this class replaces getError() with
434/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
435/// error class type.
436///
437/// Example usage of 'Expected<T>' as a function return type:
438///
439///   @code{.cpp}
440///     Expected<int> myDivide(int A, int B) {
441///       if (B == 0) {
442///         // return an Error
443///         return createStringError(inconvertibleErrorCode(),
444///                                  "B must not be zero!");
445///       }
446///       // return an integer
447///       return A / B;
448///     }
449///   @endcode
450///
451///   Checking the results of to a function returning 'Expected<T>':
452///   @code{.cpp}
453///     if (auto E = Result.takeError()) {
454///       // We must consume the error. Typically one of:
455///       // - return the error to our caller
456///       // - toString(), when logging
457///       // - consumeError(), to silently swallow the error
458///       // - handleErrors(), to distinguish error types
459///       errs() << "Problem with division " << toString(std::move(E)) << "\n";
460///       return;
461///     }
462///     // use the result
463///     outs() << "The answer is " << *Result << "\n";
464///   @endcode
465///
466///  For unit-testing a function returning an 'Expceted<T>', see the
467///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
468 
469template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
470  template <class T1> friend class ExpectedAsOutParameter;
471  template <class OtherT> friend class Expected;
472 
473  static constexpr bool isRef = std::is_reference<T>::value;
474 
475  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
476 
477  using error_type = std::unique_ptr<ErrorInfoBase>;
478 
479public:
480  using storage_type = std::conditional_t<isRef, wrap, T>;
481  using value_type = T;
482 
483private:
484  using reference = std::remove_reference_t<T> &;
485  using const_reference = const std::remove_reference_t<T> &;
486  using pointer = std::remove_reference_t<T> *;
487  using const_pointer = const std::remove_reference_t<T> *;
488 
489public:
490  /// Create an Expected<T> error value from the given Error.
491  Expected(Error Err)
492      : HasError(true)
493#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
494        // Expected is unchecked upon construction in Debug builds.
495        , Unchecked(true)
496#endif
497  {
498    assert(Err && "Cannot create Expected<T> from Error success value.")(static_cast <bool> (Err && "Cannot create Expected<T> from Error success value."
) ? void (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "llvm/include/llvm/Support/Error.h", 498, __extension__ __PRETTY_FUNCTION__
));
499    new (getErrorStorage()) error_type(Err.takePayload());
500  }
501 
502  /// Forbid to convert from Error::success() implicitly, this avoids having
503  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
504  /// but triggers the assertion above.
505  Expected(ErrorSuccess) = delete;
506 
507  /// Create an Expected<T> success value from the given OtherT value, which
508  /// must be convertible to T.
509  template <typename OtherT>
510  Expected(OtherT &&Val,
511           std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
512      : HasError(false)
513#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
514        // Expected is unchecked upon construction in Debug builds.
515        ,
516        Unchecked(true)
517#endif
518  {
519    new (getStorage()) storage_type(std::forward<OtherT>(Val));
520  }
521 
522  /// Move construct an Expected<T> value.
523  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
524 
525  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
526  /// must be convertible to T.
527  template <class OtherT>
528  Expected(
529      Expected<OtherT> &&Other,
530      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
531    moveConstruct(std::move(Other));
532  }
533 
534  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
535  /// isn't convertible to T.
536  template <class OtherT>
537  explicit Expected(
538      Expected<OtherT> &&Other,
539      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
540    moveConstruct(std::move(Other));
541  }
542 
543  /// Move-assign from another Expected<T>.
544  Expected &operator=(Expected &&Other) {
545    moveAssign(std::move(Other));
546    return *this;
547  }
548 
549  /// Destroy an Expected<T>.
550  ~Expected() {
551    assertIsChecked();
552    if (!HasError)
553      getStorage()->~storage_type();
554    else
555      getErrorStorage()->~error_type();
556  }
557 
558  /// Return false if there is an error.
559  explicit operator bool() {
560#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
561    Unchecked = HasError;
562#endif
563    return !HasError;
564  }
565 
566  /// Returns a reference to the stored T value.
567  reference get() {
568    assertIsChecked();
569    return *getStorage();
570  }
571 
572  /// Returns a const reference to the stored T value.
573  const_reference get() const {
574    assertIsChecked();
575    return const_cast<Expected<T> *>(this)->get();
576  }
577 
578  /// Returns \a takeError() after moving the held T (if any) into \p V.
579  template <class OtherT>
580  Error moveInto(OtherT &Value,
581                 std::enable_if_t<std::is_assignable<OtherT &, T &&>::value> * =
582                     nullptr) && {
583    if (*this)
38
←
Taking false branch→
584      Value = std::move(get());
585    return takeError();
39
←
Returning without writing to 'Value.ID'→
586  }
587 
588  /// Check that this Expected<T> is an error of type ErrT.
589  template <typename ErrT> bool errorIsA() const {
590    return HasError && (*getErrorStorage())->template isA<ErrT>();
591  }
592 
593  /// Take ownership of the stored error.
594  /// After calling this the Expected<T> is in an indeterminate state that can
595  /// only be safely destructed. No further calls (beside the destructor) should
596  /// be made on the Expected<T> value.
597  Error takeError() {
598#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
599    Unchecked = false;
600#endif
601    return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
602  }
603 
604  /// Returns a pointer to the stored T value.
605  pointer operator->() {
606    assertIsChecked();
607    return toPointer(getStorage());
608  }
609 
610  /// Returns a const pointer to the stored T value.
611  const_pointer operator->() const {
612    assertIsChecked();
613    return toPointer(getStorage());
614  }
615 
616  /// Returns a reference to the stored T value.
617  reference operator*() {
618    assertIsChecked();
619    return *getStorage();
620  }
621 
622  /// Returns a const reference to the stored T value.
623  const_reference operator*() const {
624    assertIsChecked();
625    return *getStorage();
626  }
627 
628private:
629  template <class T1>
630  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
631    return &a == &b;
632  }
633 
634  template <class T1, class T2>
635  static bool compareThisIfSameType(const T1 &, const T2 &) {
636    return false;
637  }
638 
639  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
640    HasError = Other.HasError;
641#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
642    Unchecked = true;
643    Other.Unchecked = false;
644#endif
645 
646    if (!HasError)
647      new (getStorage()) storage_type(std::move(*Other.getStorage()));
648    else
649      new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
650  }
651 
652  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
653    assertIsChecked();
654 
655    if (compareThisIfSameType(*this, Other))
656      return;
657 
658    this->~Expected();
659    new (this) Expected(std::move(Other));
660  }
661 
662  pointer toPointer(pointer Val) { return Val; }
663 
664  const_pointer toPointer(const_pointer Val) const { return Val; }
665 
666  pointer toPointer(wrap *Val) { return &Val->get(); }
667 
668  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
669 
670  storage_type *getStorage() {
671    assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "llvm/include/llvm/Support/Error.h", 671, __extension__ __PRETTY_FUNCTION__
));
672    return reinterpret_cast<storage_type *>(&TStorage);
673  }
674 
675  const storage_type *getStorage() const {
676    assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "llvm/include/llvm/Support/Error.h", 676, __extension__ __PRETTY_FUNCTION__
));
677    return reinterpret_cast<const storage_type *>(&TStorage);
678  }
679 
680  error_type *getErrorStorage() {
681    assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "llvm/include/llvm/Support/Error.h", 681, __extension__ __PRETTY_FUNCTION__
));
682    return reinterpret_cast<error_type *>(&ErrorStorage);
683  }
684 
685  const error_type *getErrorStorage() const {
686    assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "llvm/include/llvm/Support/Error.h", 686, __extension__ __PRETTY_FUNCTION__
));
687    return reinterpret_cast<const error_type *>(&ErrorStorage);
688  }
689 
690  // Used by ExpectedAsOutParameter to reset the checked flag.
691  void setUnchecked() {
692#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
693    Unchecked = true;
694#endif
695  }
696 
697#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
698  [[noreturn]] LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) void fatalUncheckedExpected() const {
699    dbgs() << "Expected<T> must be checked before access or destruction.\n";
700    if (HasError) {
701      dbgs() << "Unchecked Expected<T> contained error:\n";
702      (*getErrorStorage())->log(dbgs());
703    } else
704      dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
705                "values in success mode must still be checked prior to being "
706                "destroyed).\n";
707    abort();
708  }
709#endif
710 
711  void assertIsChecked() const {
712#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
713    if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
714      fatalUncheckedExpected();
715#endif
716  }
717 
718  union {
719    AlignedCharArrayUnion<storage_type> TStorage;
720    AlignedCharArrayUnion<error_type> ErrorStorage;
721  };
722  bool HasError : 1;
723#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
724  bool Unchecked : 1;
725#endif
726};
727 
728/// Report a serious error, calling any installed error handler. See
729/// ErrorHandling.h.
730[[noreturn]] void report_fatal_error(Error Err, bool gen_crash_diag = true);
731 
732/// Report a fatal error if Err is a failure value.
733///
734/// This function can be used to wrap calls to fallible functions ONLY when it
735/// is known that the Error will always be a success value. E.g.
736///
737///   @code{.cpp}
738///   // foo only attempts the fallible operation if DoFallibleOperation is
739///   // true. If DoFallibleOperation is false then foo always returns
740///   // Error::success().
741///   Error foo(bool DoFallibleOperation);
742///
743///   cantFail(foo(false));
744///   @endcode
745inline void cantFail(Error Err, const char *Msg = nullptr) {
746  if (Err) {
747    if (!Msg)
748      Msg = "Failure value returned from cantFail wrapped call";
749#ifndef NDEBUG
750    std::string Str;
751    raw_string_ostream OS(Str);
752    OS << Msg << "\n" << Err;
753    Msg = OS.str().c_str();
754#endif
755    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "llvm/include/llvm/Support/Error.h"
, 755);
756  }
757}
758 
759/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
760/// returns the contained value.
761///
762/// This function can be used to wrap calls to fallible functions ONLY when it
763/// is known that the Error will always be a success value. E.g.
764///
765///   @code{.cpp}
766///   // foo only attempts the fallible operation if DoFallibleOperation is
767///   // true. If DoFallibleOperation is false then foo always returns an int.
768///   Expected<int> foo(bool DoFallibleOperation);
769///
770///   int X = cantFail(foo(false));
771///   @endcode
772template <typename T>
773T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
774  if (ValOrErr)
775    return std::move(*ValOrErr);
776  else {
777    if (!Msg)
778      Msg = "Failure value returned from cantFail wrapped call";
779#ifndef NDEBUG
780    std::string Str;
781    raw_string_ostream OS(Str);
782    auto E = ValOrErr.takeError();
783    OS << Msg << "\n" << E;
784    Msg = OS.str().c_str();
785#endif
786    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "llvm/include/llvm/Support/Error.h"
, 786);
787  }
788}
789 
790/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
791/// returns the contained reference.
792///
793/// This function can be used to wrap calls to fallible functions ONLY when it
794/// is known that the Error will always be a success value. E.g.
795///
796///   @code{.cpp}
797///   // foo only attempts the fallible operation if DoFallibleOperation is
798///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
799///   Expected<Bar&> foo(bool DoFallibleOperation);
800///
801///   Bar &X = cantFail(foo(false));
802///   @endcode
803template <typename T>
804T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
805  if (ValOrErr)
806    return *ValOrErr;
807  else {
808    if (!Msg)
809      Msg = "Failure value returned from cantFail wrapped call";
810#ifndef NDEBUG
811    std::string Str;
812    raw_string_ostream OS(Str);
813    auto E = ValOrErr.takeError();
814    OS << Msg << "\n" << E;
815    Msg = OS.str().c_str();
816#endif
817    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "llvm/include/llvm/Support/Error.h"
, 817);
818  }
819}
820 
821/// Helper for testing applicability of, and applying, handlers for
822/// ErrorInfo types.
823template <typename HandlerT>
824class ErrorHandlerTraits
825    : public ErrorHandlerTraits<decltype(
826          &std::remove_reference<HandlerT>::type::operator())> {};
827 
828// Specialization functions of the form 'Error (const ErrT&)'.
829template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
830public:
831  static bool appliesTo(const ErrorInfoBase &E) {
832    return E.template isA<ErrT>();
833  }
834 
835  template <typename HandlerT>
836  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
837    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "llvm/include/llvm/Support/Error.h", 837, __extension__ __PRETTY_FUNCTION__
));
838    return H(static_cast<ErrT &>(*E));
839  }
840};
841 
842// Specialization functions of the form 'void (const ErrT&)'.
843template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
844public:
845  static bool appliesTo(const ErrorInfoBase &E) {
846    return E.template isA<ErrT>();
847  }
848 
849  template <typename HandlerT>
850  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
851    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "llvm/include/llvm/Support/Error.h", 851, __extension__ __PRETTY_FUNCTION__
));
852    H(static_cast<ErrT &>(*E));
853    return Error::success();
854  }
855};
856 
857/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
858template <typename ErrT>
859class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
860public:
861  static bool appliesTo(const ErrorInfoBase &E) {
862    return E.template isA<ErrT>();
863  }
864 
865  template <typename HandlerT>
866  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
867    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "llvm/include/llvm/Support/Error.h", 867, __extension__ __PRETTY_FUNCTION__
));
868    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
869    return H(std::move(SubE));
870  }
871};
872 
873/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
874template <typename ErrT>
875class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
876public:
877  static bool appliesTo(const ErrorInfoBase &E) {
878    return E.template isA<ErrT>();
879  }
880 
881  template <typename HandlerT>
882  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
883    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "llvm/include/llvm/Support/Error.h", 883, __extension__ __PRETTY_FUNCTION__
));
884    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
885    H(std::move(SubE));
886    return Error::success();
887  }
888};
889 
890// Specialization for member functions of the form 'RetT (const ErrT&)'.
891template <typename C, typename RetT, typename ErrT>
892class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
893    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
894 
895// Specialization for member functions of the form 'RetT (const ErrT&) const'.
896template <typename C, typename RetT, typename ErrT>
897class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
898    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
899 
900// Specialization for member functions of the form 'RetT (const ErrT&)'.
901template <typename C, typename RetT, typename ErrT>
902class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
903    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
904 
905// Specialization for member functions of the form 'RetT (const ErrT&) const'.
906template <typename C, typename RetT, typename ErrT>
907class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
908    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
909 
910/// Specialization for member functions of the form
911/// 'RetT (std::unique_ptr<ErrT>)'.
912template <typename C, typename RetT, typename ErrT>
913class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
914    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
915 
916/// Specialization for member functions of the form
917/// 'RetT (std::unique_ptr<ErrT>) const'.
918template <typename C, typename RetT, typename ErrT>
919class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
920    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
921 
922inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
923  return Error(std::move(Payload));
924}
925 
926template <typename HandlerT, typename... HandlerTs>
927Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
928                      HandlerT &&Handler, HandlerTs &&... Handlers) {
929  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
930    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
931                                               std::move(Payload));
932  return handleErrorImpl(std::move(Payload),
933                         std::forward<HandlerTs>(Handlers)...);
934}
935 
936/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
937/// unhandled errors (or Errors returned by handlers) are re-concatenated and
938/// returned.
939/// Because this function returns an error, its result must also be checked
940/// or returned. If you intend to handle all errors use handleAllErrors
941/// (which returns void, and will abort() on unhandled errors) instead.
942template <typename... HandlerTs>
943Error handleErrors(Error E, HandlerTs &&... Hs) {
944  if (!E)
945    return Error::success();
946 
947  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
948 
949  if (Payload->isA<ErrorList>()) {
950    ErrorList &List = static_cast<ErrorList &>(*Payload);
951    Error R;
952    for (auto &P : List.Payloads)
953      R = ErrorList::join(
954          std::move(R),
955          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
956    return R;
957  }
958 
959  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
960}
961 
962/// Behaves the same as handleErrors, except that by contract all errors
963/// *must* be handled by the given handlers (i.e. there must be no remaining
964/// errors after running the handlers, or llvm_unreachable is called).
965template <typename... HandlerTs>
966void handleAllErrors(Error E, HandlerTs &&... Handlers) {
967  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
968}
969 
970/// Check that E is a non-error, then drop it.
971/// If E is an error, llvm_unreachable will be called.
972inline void handleAllErrors(Error E) {
973  cantFail(std::move(E));
974}
975 
976/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
977///
978/// If the incoming value is a success value it is returned unmodified. If it
979/// is a failure value then it the contained error is passed to handleErrors.
980/// If handleErrors is able to handle the error then the RecoveryPath functor
981/// is called to supply the final result. If handleErrors is not able to
982/// handle all errors then the unhandled errors are returned.
983///
984/// This utility enables the follow pattern:
985///
986///   @code{.cpp}
987///   enum FooStrategy { Aggressive, Conservative };
988///   Expected<Foo> foo(FooStrategy S);
989///
990///   auto ResultOrErr =
991///     handleExpected(
992///       foo(Aggressive),
993///       []() { return foo(Conservative); },
994///       [](AggressiveStrategyError&) {
995///         // Implicitly conusme this - we'll recover by using a conservative
996///         // strategy.
997///       });
998///
999///   @endcode
1000template <typename T, typename RecoveryFtor, typename... HandlerTs>
1001Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
1002                           HandlerTs &&... Handlers) {
1003  if (ValOrErr)
1004    return ValOrErr;
1005 
1006  if (auto Err = handleErrors(ValOrErr.takeError(),
1007                              std::forward<HandlerTs>(Handlers)...))
1008    return std::move(Err);
1009 
1010  return RecoveryPath();
1011}
1012 
1013/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
1014/// will be printed before the first one is logged. A newline will be printed
1015/// after each error.
1016///
1017/// This function is compatible with the helpers from Support/WithColor.h. You
1018/// can pass any of them as the OS. Please consider using them instead of
1019/// including 'error: ' in the ErrorBanner.
1020///
1021/// This is useful in the base level of your program to allow clean termination
1022/// (allowing clean deallocation of resources, etc.), while reporting error
1023/// information to the user.
1024void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
1025 
1026/// Write all error messages (if any) in E to a string. The newline character
1027/// is used to separate error messages.
1028inline std::string toString(Error E) {
1029  SmallVector<std::string, 2> Errors;
1030  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
1031    Errors.push_back(EI.message());
1032  });
1033  return join(Errors.begin(), Errors.end(), "\n");
1034}
1035 
1036/// Consume a Error without doing anything. This method should be used
1037/// only where an error can be considered a reasonable and expected return
1038/// value.
1039///
1040/// Uses of this method are potentially indicative of design problems: If it's
1041/// legitimate to do nothing while processing an "error", the error-producer
1042/// might be more clearly refactored to return an Optional<T>.
1043inline void consumeError(Error Err) {
1044  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
1045}
1046 
1047/// Convert an Expected to an Optional without doing anything. This method
1048/// should be used only where an error can be considered a reasonable and
1049/// expected return value.
1050///
1051/// Uses of this method are potentially indicative of problems: perhaps the
1052/// error should be propagated further, or the error-producer should just
1053/// return an Optional in the first place.
1054template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
1055  if (E)
1056    return std::move(*E);
1057  consumeError(E.takeError());
1058  return None;
1059}
1060 
1061/// Helper for converting an Error to a bool.
1062///
1063/// This method returns true if Err is in an error state, or false if it is
1064/// in a success state.  Puts Err in a checked state in both cases (unlike
1065/// Error::operator bool(), which only does this for success states).
1066inline bool errorToBool(Error Err) {
1067  bool IsError = static_cast<bool>(Err);
1068  if (IsError)
1069    consumeError(std::move(Err));
1070  return IsError;
1071}
1072 
1073/// Helper for Errors used as out-parameters.
1074///
1075/// This helper is for use with the Error-as-out-parameter idiom, where an error
1076/// is passed to a function or method by reference, rather than being returned.
1077/// In such cases it is helpful to set the checked bit on entry to the function
1078/// so that the error can be written to (unchecked Errors abort on assignment)
1079/// and clear the checked bit on exit so that clients cannot accidentally forget
1080/// to check the result. This helper performs these actions automatically using
1081/// RAII:
1082///
1083///   @code{.cpp}
1084///   Result foo(Error &Err) {
1085///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1086///     // <body of foo>
1087///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1088///   }
1089///   @endcode
1090///
1091/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1092/// used with optional Errors (Error pointers that are allowed to be null). If
1093/// ErrorAsOutParameter took an Error reference, an instance would have to be
1094/// created inside every condition that verified that Error was non-null. By
1095/// taking an Error pointer we can just create one instance at the top of the
1096/// function.
1097class ErrorAsOutParameter {
1098public:
1099  ErrorAsOutParameter(Error *Err) : Err(Err) {
1100    // Raise the checked bit if Err is success.
1101    if (Err)
1102      (void)!!*Err;
1103  }
1104 
1105  ~ErrorAsOutParameter() {
1106    // Clear the checked bit.
1107    if (Err && !*Err)
1108      *Err = Error::success();
1109  }
1110 
1111private:
1112  Error *Err;
1113};
1114 
1115/// Helper for Expected<T>s used as out-parameters.
1116///
1117/// See ErrorAsOutParameter.
1118template <typename T>
1119class ExpectedAsOutParameter {
1120public:
1121  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1122    : ValOrErr(ValOrErr) {
1123    if (ValOrErr)
1124      (void)!!*ValOrErr;
1125  }
1126 
1127  ~ExpectedAsOutParameter() {
1128    if (ValOrErr)
1129      ValOrErr->setUnchecked();
1130  }
1131 
1132private:
1133  Expected<T> *ValOrErr;
1134};
1135 
1136/// This class wraps a std::error_code in a Error.
1137///
1138/// This is useful if you're writing an interface that returns a Error
1139/// (or Expected) and you want to call code that still returns
1140/// std::error_codes.
1141class ECError : public ErrorInfo<ECError> {
1142  friend Error errorCodeToError(std::error_code);
1143 
1144  virtual void anchor() override;
1145 
1146public:
1147  void setErrorCode(std::error_code EC) { this->EC = EC; }
1148  std::error_code convertToErrorCode() const override { return EC; }
1149  void log(raw_ostream &OS) const override { OS << EC.message(); }
1150 
1151  // Used by ErrorInfo::classID.
1152  static char ID;
1153 
1154protected:
1155  ECError() = default;
1156  ECError(std::error_code EC) : EC(EC) {}
1157 
1158  std::error_code EC;
1159};
1160 
1161/// The value returned by this function can be returned from convertToErrorCode
1162/// for Error values where no sensible translation to std::error_code exists.
1163/// It should only be used in this situation, and should never be used where a
1164/// sensible conversion to std::error_code is available, as attempts to convert
1165/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1166/// error to try to convert such a value).
1167std::error_code inconvertibleErrorCode();
1168 
1169/// Helper for converting an std::error_code to a Error.
1170Error errorCodeToError(std::error_code EC);
1171 
1172/// Helper for converting an ECError to a std::error_code.
1173///
1174/// This method requires that Err be Error() or an ECError, otherwise it
1175/// will trigger a call to abort().
1176std::error_code errorToErrorCode(Error Err);
1177 
1178/// Convert an ErrorOr<T> to an Expected<T>.
1179template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1180  if (auto EC = EO.getError())
1181    return errorCodeToError(EC);
1182  return std::move(*EO);
1183}
1184 
1185/// Convert an Expected<T> to an ErrorOr<T>.
1186template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1187  if (auto Err = E.takeError())
1188    return errorToErrorCode(std::move(Err));
1189  return std::move(*E);
1190}
1191 
1192/// This class wraps a string in an Error.
1193///
1194/// StringError is useful in cases where the client is not expected to be able
1195/// to consume the specific error message programmatically (for example, if the
1196/// error message is to be presented to the user).
1197///
1198/// StringError can also be used when additional information is to be printed
1199/// along with a error_code message. Depending on the constructor called, this
1200/// class can either display:
1201///    1. the error_code message (ECError behavior)
1202///    2. a string
1203///    3. the error_code message and a string
1204///
1205/// These behaviors are useful when subtyping is required; for example, when a
1206/// specific library needs an explicit error type. In the example below,
1207/// PDBError is derived from StringError:
1208///
1209///   @code{.cpp}
1210///   Expected<int> foo() {
1211///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1212///                                        "Additional information");
1213///   }
1214///   @endcode
1215///
1216class StringError : public ErrorInfo<StringError> {
1217public:
1218  static char ID;
1219 
1220  // Prints EC + S and converts to EC
1221  StringError(std::error_code EC, const Twine &S = Twine());
1222 
1223  // Prints S and converts to EC
1224  StringError(const Twine &S, std::error_code EC);
1225 
1226  void log(raw_ostream &OS) const override;
1227  std::error_code convertToErrorCode() const override;
1228 
1229  const std::string &getMessage() const { return Msg; }
1230 
1231private:
1232  std::string Msg;
1233  std::error_code EC;
1234  const bool PrintMsgOnly = false;
1235};
1236 
1237/// Create formatted StringError object.
1238template <typename... Ts>
1239inline Error createStringError(std::error_code EC, char const *Fmt,
1240                               const Ts &... Vals) {
1241  std::string Buffer;
1242  raw_string_ostream Stream(Buffer);
1243  Stream << format(Fmt, Vals...);
1244  return make_error<StringError>(Stream.str(), EC);
1245}
1246 
1247Error createStringError(std::error_code EC, char const *Msg);
1248 
1249inline Error createStringError(std::error_code EC, const Twine &S) {
1250  return createStringError(EC, S.str().c_str());
1251}
1252 
1253template <typename... Ts>
1254inline Error createStringError(std::errc EC, char const *Fmt,
1255                               const Ts &... Vals) {
1256  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1257}
1258 
1259/// This class wraps a filename and another Error.
1260///
1261/// In some cases, an error needs to live along a 'source' name, in order to
1262/// show more detailed information to the user.
1263class FileError final : public ErrorInfo<FileError> {
1264 
1265  friend Error createFileError(const Twine &, Error);
1266  friend Error createFileError(const Twine &, size_t, Error);
1267 
1268public:
1269  void log(raw_ostream &OS) const override {
1270    assert(Err && "Trying to log after takeError().")(static_cast <bool> (Err && "Trying to log after takeError()."
) ? void (0) : __assert_fail ("Err && \"Trying to log after takeError().\""
, "llvm/include/llvm/Support/Error.h", 1270, __extension__ __PRETTY_FUNCTION__
));
1271    OS << "'" << FileName << "': ";
1272    if (Line.hasValue())
1273      OS << "line " << Line.getValue() << ": ";
1274    Err->log(OS);
1275  }
1276 
1277  std::string messageWithoutFileInfo() const {
1278    std::string Msg;
1279    raw_string_ostream OS(Msg);
1280    Err->log(OS);
1281    return OS.str();
1282  }
1283 
1284  StringRef getFileName() const { return FileName; }
1285 
1286  Error takeError() { return Error(std::move(Err)); }
1287 
1288  std::error_code convertToErrorCode() const override;
1289 
1290  // Used by ErrorInfo::classID.
1291  static char ID;
1292 
1293private:
1294  FileError(const Twine &F, Optional<size_t> LineNum,
1295            std::unique_ptr<ErrorInfoBase> E) {
1296    assert(E && "Cannot create FileError from Error success value.")(static_cast <bool> (E && "Cannot create FileError from Error success value."
) ? void (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "llvm/include/llvm/Support/Error.h", 1296, __extension__ __PRETTY_FUNCTION__
));
1297    FileName = F.str();
1298    Err = std::move(E);
1299    Line = std::move(LineNum);
1300  }
1301 
1302  static Error build(const Twine &F, Optional<size_t> Line, Error E) {
1303    std::unique_ptr<ErrorInfoBase> Payload;
1304    handleAllErrors(std::move(E),
1305                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1306                      Payload = std::move(EIB);
1307                      return Error::success();
1308                    });
1309    return Error(
1310        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1311  }
1312 
1313  std::string FileName;
1314  Optional<size_t> Line;
1315  std::unique_ptr<ErrorInfoBase> Err;
1316};
1317 
1318/// Concatenate a source file path and/or name with an Error. The resulting
1319/// Error is unchecked.
1320inline Error createFileError(const Twine &F, Error E) {
1321  return FileError::build(F, Optional<size_t>(), std::move(E));
1322}
1323 
1324/// Concatenate a source file path and/or name with line number and an Error.
1325/// The resulting Error is unchecked.
1326inline Error createFileError(const Twine &F, size_t Line, Error E) {
1327  return FileError::build(F, Optional<size_t>(Line), std::move(E));
1328}
1329 
1330/// Concatenate a source file path and/or name with a std::error_code 
1331/// to form an Error object.
1332inline Error createFileError(const Twine &F, std::error_code EC) {
1333  return createFileError(F, errorCodeToError(EC));
1334}
1335 
1336/// Concatenate a source file path and/or name with line number and
1337/// std::error_code to form an Error object.
1338inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1339  return createFileError(F, Line, errorCodeToError(EC));
1340}
1341 
1342Error createFileError(const Twine &F, ErrorSuccess) = delete;
1343 
1344/// Helper for check-and-exit error handling.
1345///
1346/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1347///
1348class ExitOnError {
1349public:
1350  /// Create an error on exit helper.
1351  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1352      : Banner(std::move(Banner)),
1353        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1354 
1355  /// Set the banner string for any errors caught by operator().
1356  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1357 
1358  /// Set the exit-code mapper function.
1359  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1360    this->GetExitCode = std::move(GetExitCode);
1361  }
1362 
1363  /// Check Err. If it's in a failure state log the error(s) and exit.
1364  void operator()(Error Err) const { checkError(std::move(Err)); }
1365 
1366  /// Check E. If it's in a success state then return the contained value. If
1367  /// it's in a failure state log the error(s) and exit.
1368  template <typename T> T operator()(Expected<T> &&E) const {
1369    checkError(E.takeError());
1370    return std::move(*E);
1371  }
1372 
1373  /// Check E. If it's in a success state then return the contained reference. If
1374  /// it's in a failure state log the error(s) and exit.
1375  template <typename T> T& operator()(Expected<T&> &&E) const {
1376    checkError(E.takeError());
1377    return *E;
1378  }
1379 
1380private:
1381  void checkError(Error Err) const {
1382    if (Err) {
1383      int ExitCode = GetExitCode(Err);
1384      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1385      exit(ExitCode);
1386    }
1387  }
1388 
1389  std::string Banner;
1390  std::function<int(const Error &)> GetExitCode;
1391};
1392 
1393/// Conversion from Error to LLVMErrorRef for C error bindings.
1394inline LLVMErrorRef wrap(Error Err) {
1395  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1396}
1397 
1398/// Conversion from LLVMErrorRef to Error for C error bindings.
1399inline Error unwrap(LLVMErrorRef ErrRef) {
1400  return Error(std::unique_ptr<ErrorInfoBase>(
1401      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1402}
1403 
1404} // end namespace llvm
1405 
1406#endif // LLVM_SUPPORT_ERROR_H