/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h

Bug Summary

File:	include/llvm/Bitcode/BitstreamReader.h
Warning:	line 208, column 39 The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Bitcode/Reader -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/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/APFloat.h"
13#include "llvm/ADT/APInt.h"
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/DenseSet.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallString.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/Statistic.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/Bitcode/BitcodeReader.h"
25#include "llvm/Bitcode/BitstreamReader.h"
26#include "llvm/Bitcode/LLVMBitCodes.h"
27#include "llvm/IR/Argument.h"
28#include "llvm/IR/Attributes.h"
29#include "llvm/IR/AutoUpgrade.h"
30#include "llvm/IR/BasicBlock.h"
31#include "llvm/IR/CallingConv.h"
32#include "llvm/IR/Comdat.h"
33#include "llvm/IR/Constant.h"
34#include "llvm/IR/Constants.h"
35#include "llvm/IR/DebugInfo.h"
36#include "llvm/IR/DebugInfoMetadata.h"
37#include "llvm/IR/DebugLoc.h"
38#include "llvm/IR/DerivedTypes.h"
39#include "llvm/IR/DiagnosticPrinter.h"
40#include "llvm/IR/Function.h"
41#include "llvm/IR/GVMaterializer.h"
42#include "llvm/IR/GlobalAlias.h"
43#include "llvm/IR/GlobalIFunc.h"
44#include "llvm/IR/GlobalIndirectSymbol.h"
45#include "llvm/IR/GlobalObject.h"
46#include "llvm/IR/GlobalValue.h"
47#include "llvm/IR/GlobalVariable.h"
48#include "llvm/IR/InlineAsm.h"
49#include "llvm/IR/InstrTypes.h"
50#include "llvm/IR/Instruction.h"
51#include "llvm/IR/Instructions.h"
52#include "llvm/IR/IntrinsicInst.h"
53#include "llvm/IR/Intrinsics.h"
54#include "llvm/IR/LLVMContext.h"
55#include "llvm/IR/Module.h"
56#include "llvm/IR/ModuleSummaryIndex.h"
57#include "llvm/IR/OperandTraits.h"
58#include "llvm/IR/TrackingMDRef.h"
59#include "llvm/IR/Type.h"
60#include "llvm/IR/ValueHandle.h"
61#include "llvm/Support/AtomicOrdering.h"
62#include "llvm/Support/Casting.h"
63#include "llvm/Support/CommandLine.h"
64#include "llvm/Support/Compiler.h"
65#include "llvm/Support/Debug.h"
66#include "llvm/Support/Error.h"
67#include "llvm/Support/ErrorHandling.h"
68#include "llvm/Support/ManagedStatic.h"
69#include "llvm/Support/MemoryBuffer.h"
70#include "llvm/Support/raw_ostream.h"
71#include <algorithm>
72#include <cassert>
73#include <cstddef>
74#include <cstdint>
75#include <deque>
76#include <limits>
77#include <map>
78#include <memory>
79#include <string>
80#include <system_error>
81#include <tuple>
82#include <utility>
83#include <vector>

85using namespace llvm;

87#define DEBUG_TYPE"bitcode-reader" "bitcode-reader"

89STATISTIC(NumMDStringLoaded, "Number of MDStrings loaded")static llvm::Statistic NumMDStringLoaded = {"bitcode-reader",
 "NumMDStringLoaded", "Number of MDStrings loaded", {0}, {false
}};
90STATISTIC(NumMDNodeTemporary, "Number of MDNode::Temporary created")static llvm::Statistic NumMDNodeTemporary = {"bitcode-reader"
, "NumMDNodeTemporary", "Number of MDNode::Temporary created"
, {0}, {false}};
91STATISTIC(NumMDRecordLoaded, "Number of Metadata records loaded")static llvm::Statistic NumMDRecordLoaded = {"bitcode-reader",
 "NumMDRecordLoaded", "Number of Metadata records loaded", {0
}, {false}};

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

99static 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."));

104namespace {

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

108class 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;

133public:
BitcodeReaderMetadataList(LLVMContext &C) : Context(C) {}

// 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())((i < MetadataPtrs.size()) ? static_cast<void> (0) :
 __assert_fail ("i < MetadataPtrs.size()", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 146, __PRETTY_FUNCTION__));
  return MetadataPtrs[i];
}

Metadata *lookup(unsigned I) const {
  if (I < MetadataPtrs.size())
    return MetadataPtrs[I];
  return nullptr;
}

void shrinkTo(unsigned N) {
  assert(N <= size() && "Invalid shrinkTo request!")((N <= size() && "Invalid shrinkTo request!") ? static_cast
<void> (0) : __assert_fail ("N <= size() && \"Invalid shrinkTo request!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 157, __PRETTY_FUNCTION__));
  assert(ForwardReference.empty() && "Unexpected forward refs")((ForwardReference.empty() && "Unexpected forward refs"
) ? static_cast<void> (0) : __assert_fail ("ForwardReference.empty() && \"Unexpected forward refs\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 158, __PRETTY_FUNCTION__));
  assert(UnresolvedNodes.empty() && "Unexpected unresolved node")((UnresolvedNodes.empty() && "Unexpected unresolved node"
) ? static_cast<void> (0) : __assert_fail ("UnresolvedNodes.empty() && \"Unexpected unresolved node\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 159, __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())((hasFwdRefs()) ? static_cast<void> (0) : __assert_fail
 ("hasFwdRefs()", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 178, __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);

191private:
Metadata *resolveTypeRefArray(Metadata *MaybeTuple);
193};

195void 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);
218}

220Metadata *BitcodeReaderMetadataList::getMetadataFwdRef(unsigned Idx) {
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;
235}

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

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

249void 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")((!N->isTemporary() && "Unexpected forward reference"
) ? static_cast<void> (0) : __assert_fail ("!N->isTemporary() && \"Unexpected forward reference\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 287, __PRETTY_FUNCTION__));
  N->resolveCycles();
}

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

295void BitcodeReaderMetadataList::addTypeRef(MDString &UUID,
                                         DICompositeType &CT) {
assert(CT.getRawIdentifier() == &UUID && "Mismatched UUID")((CT.getRawIdentifier() == &UUID && "Mismatched UUID"
) ? static_cast<void> (0) : __assert_fail ("CT.getRawIdentifier() == &UUID && \"Mismatched UUID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 297, __PRETTY_FUNCTION__));
if (CT.isForwardDecl())
  OldTypeRefs.FwdDecls.insert(std::make_pair(&UUID, &CT));
else
  OldTypeRefs.Final.insert(std::make_pair(&UUID, &CT));
302}

304Metadata *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();
316}

318Metadata *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();
333}

335Metadata *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);
347}

349namespace {

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

356public:
~PlaceholderQueue() {
  assert(empty() && "PlaceholderQueue hasn't been flushed before being destroyed")((empty() && "PlaceholderQueue hasn't been flushed before being destroyed"
) ? static_cast<void> (0) : __assert_fail ("empty() && \"PlaceholderQueue hasn't been flushed before being destroyed\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 358, __PRETTY_FUNCTION__));
}
bool empty() { 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);
  }
}
380};

382} // end anonymous namespace

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

389void PlaceholderQueue::flush(BitcodeReaderMetadataList &MetadataList) {
while (!PHs.empty()) {
  auto *MD = MetadataList.lookup(PHs.front().getID());
  assert(MD && "Flushing placeholder on unassigned MD")((MD && "Flushing placeholder on unassigned MD") ? static_cast
<void> (0) : __assert_fail ("MD && \"Flushing placeholder on unassigned MD\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 392, __PRETTY_FUNCTION__));
393#ifndef NDEBUG
  if (auto *MDN = dyn_cast<MDNode>(MD))
    assert(MDN->isResolved() &&((MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? static_cast<void> (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 396, __PRETTY_FUNCTION__))
           "Flushing Placeholder while cycles aren't resolved")((MDN->isResolved() && "Flushing Placeholder while cycles aren't resolved"
) ? static_cast<void> (0) : __assert_fail ("MDN->isResolved() && \"Flushing Placeholder while cycles aren't resolved\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 396, __PRETTY_FUNCTION__));
397#endif
  PHs.front().replaceUseWith(MD);
  PHs.pop_front();
}
401}

403} // anonynous namespace

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

410class 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;

/// 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_or_null<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() &&
              dyn_cast_or_null<Argument>(DDI->getAddress())) {
            SmallVector<uint64_t, 8> Ops;
            Ops.append(std::next(DIExpr->elements_begin()),
                       DIExpr->elements_end());
            auto *E = DIExpression::get(Context, Ops);
            DDI->setOperand(2, MetadataAsValue::get(Context, E));
          }
}

/// 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[[clang::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[[clang::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[[clang::fallthrough]];
  }
  case 3:
    // Up-to-date!
    break;
  }

  return Error::success();
}

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

623public:
MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
                   BitcodeReaderValueList &ValueList,
                   std::function<Type *(unsigned)> getTypeByID,
                   bool IsImporting)
    : MetadataList(TheModule.getContext()), 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())
    return lazyLoadOneMDString(ID);
  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())) {
    PlaceholderQueue Placeholders;
    lazyLoadOneMetadata(ID, Placeholders);
    resolveForwardRefsAndPlaceholders(Placeholders);
    return MetadataList.lookup(ID);
  }
  return MetadataList.getMetadataFwdRef(ID);
}

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

bool hasSeenOldLoopTags() { return HasSeenOldLoopTags; }

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

Error parseMetadataKinds();

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

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

671Expected<bool>
672MetadataLoader::MetadataLoaderImpl::lazyLoadModuleMetadataBlock() {
IndexCursor = Stream;
SmallVector<uint64_t, 64> Record;
// Get the abbrevs, and preload record positions to make them lazy-loadable.
while (true) {
  BitstreamEntry Entry = IndexCursor.advanceSkippingSubblocks(
      BitstreamCursor::AF_DontPopBlockAtEnd);
  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();
    auto Code = IndexCursor.skipRecord(Entry.ID);
    switch (Code) {
    case bitc::METADATA_STRINGS: {
      // Rewind and parse the strings.
      IndexCursor.JumpToBit(CurrentPos);
      StringRef Blob;
      Record.clear();
      IndexCursor.readRecord(Entry.ID, Record, &Blob);
      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.
      IndexCursor.JumpToBit(CurrentPos);
      Record.clear();
      IndexCursor.readRecord(Entry.ID, Record);
      if (Record.size() != 2)
        return error("Invalid record");
      auto Offset = Record[0] + (Record[1] << 32);
      auto BeginPos = IndexCursor.GetCurrentBitNo();
      IndexCursor.JumpToBit(BeginPos + Offset);
      Entry = IndexCursor.advanceSkippingSubblocks(
          BitstreamCursor::AF_DontPopBlockAtEnd);
      assert(Entry.Kind == BitstreamEntry::Record &&((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? static_cast<void> (0) : __assert_fail
 ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 722, __PRETTY_FUNCTION__))
             "Corrupted bitcode: Expected `Record` when trying to find the "((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? static_cast<void> (0) : __assert_fail
 ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 722, __PRETTY_FUNCTION__))
             "Metadata index")((Entry.Kind == BitstreamEntry::Record && "Corrupted bitcode: Expected `Record` when trying to find the "
 "Metadata index") ? static_cast<void> (0) : __assert_fail
 ("Entry.Kind == BitstreamEntry::Record && \"Corrupted bitcode: Expected `Record` when trying to find the \" \"Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 722, __PRETTY_FUNCTION__));
      Record.clear();
      auto Code = IndexCursor.readRecord(Entry.ID, Record);
      (void)Code;
      assert(Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
 "`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 728, __PRETTY_FUNCTION__))
                                             "`METADATA_INDEX` when trying "((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
 "`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 728, __PRETTY_FUNCTION__))
                                             "to find the Metadata index")((Code == bitc::METADATA_INDEX && "Corrupted bitcode: Expected "
 "`METADATA_INDEX` when trying " "to find the Metadata index"
) ? static_cast<void> (0) : __assert_fail ("Code == bitc::METADATA_INDEX && \"Corrupted bitcode: Expected \" \"`METADATA_INDEX` when trying \" \"to find the Metadata index\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 728, __PRETTY_FUNCTION__));

      // 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.
      IndexCursor.JumpToBit(CurrentPos);
      Record.clear();
      unsigned Code = IndexCursor.readRecord(Entry.ID, Record);
      assert(Code == bitc::METADATA_NAME)((Code == bitc::METADATA_NAME) ? static_cast<void> (0) :
 __assert_fail ("Code == bitc::METADATA_NAME", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 748, __PRETTY_FUNCTION__));

      // Read name of the named metadata.
      SmallString<8> Name(Record.begin(), Record.end());
      Code = IndexCursor.ReadCode();

      // Named Metadata comes in two parts, we expect the name to be followed
      // by the node
      Record.clear();
      unsigned NextBitCode = IndexCursor.readRecord(Code, Record);
      assert(NextBitCode == bitc::METADATA_NAMED_NODE)((NextBitCode == bitc::METADATA_NAMED_NODE) ? static_cast<
void> (0) : __assert_fail ("NextBitCode == bitc::METADATA_NAMED_NODE"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 758, __PRETTY_FUNCTION__));
      (void)NextBitCode;

      // 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")((MD && "Invalid metadata: expect fwd ref to MDNode")
 ? static_cast<void> (0) : __assert_fail ("MD && \"Invalid metadata: expect fwd ref to MDNode\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 770, __PRETTY_FUNCTION__));
        NMD->addOperand(MD);
      }
      break;
    }
    case bitc::METADATA_GLOBAL_DECL_ATTACHMENT: {
      // FIXME: we need to do this early because we don't materialize global
      // value explicitly.
      IndexCursor.JumpToBit(CurrentPos);
      Record.clear();
      IndexCursor.readRecord(Entry.ID, Record);
      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 std::move(Err);
      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_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:
      // 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;
  }
  }
}
836}

838/// Parse a METADATA_BLOCK. If ModuleLevel is true then we are parsing
839/// module level metadata.
840Error 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 (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
  return error("Invalid record");

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());

    // 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.
    Stream.JumpToBit(EntryPos);
    if (Stream.SkipBlock())
      return error("Invalid record");
    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 = Stream.advanceSkippingSubblocks();

  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;
  unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
  if (Error Err =
          parseOneMetadata(Record, Code, Placeholders, Blob, NextMetadataNo))
    return Err;
}
910}

912MDString *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;
919}

921void MetadataLoader::MetadataLoaderImpl::lazyLoadOneMetadata(
  unsigned ID, PlaceholderQueue &Placeholders) {
assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size())((ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size
()) ? static_cast<void> (0) : __assert_fail ("ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size()"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 923, __PRETTY_FUNCTION__));
assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString")((ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString"
) ? static_cast<void> (0) : __assert_fail ("ID >= MDStringRef.size() && \"Unexpected lazy-loading of MDString\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 924, __PRETTY_FUNCTION__));
// Lookup first if the metadata hasn't already been loaded.
if (auto *MD = MetadataList.lookup(ID)) {
  auto *N = dyn_cast_or_null<MDNode>(MD);
  if (!N->isTemporary())
    return;
}
SmallVector<uint64_t, 64> Record;
StringRef Blob;
IndexCursor.JumpToBit(GlobalMetadataBitPosIndex[ID - MDStringRef.size()]);
auto Entry = IndexCursor.advanceSkippingSubblocks();
++NumMDRecordLoaded;
unsigned Code = IndexCursor.readRecord(Entry.ID, Record, &Blob);
if (Error Err = parseOneMetadata(Record, Code, Placeholders, Blob, ID))
  report_fatal_error("Can't lazyload MD");
939}

941/// Ensure that all forward-references and placeholders are resolved.
942/// Iteratively lazy-loading metadata on-demand if needed.
943void MetadataLoader::MetadataLoaderImpl::resolveForwardRefsAndPlaceholders(
  PlaceholderQueue &Placeholders) {
DenseSet<unsigned> Temporaries;
while (1) {
  // 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);
973}

975Error 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));
};

1025#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();
  Code = Stream.ReadCode();

  ++NumMDRecordLoaded;
  unsigned NextBitCode = Stream.readRecord(Code, Record);
  if (NextBitCode != bitc::METADATA_NAMED_NODE)
    return error("METADATA_NAME not followed by METADATA_NAMED_NODE");

  // 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: {
  // FIXME: Remove in 4.0.
  // 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;
  }

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

  MetadataList.assignValue(
      LocalAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_OLD_NODE: {
  // FIXME: Remove in 4.0.
  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) {
    Type *Ty = getTypeByID(Record[i]);
    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));
      assert(isa<ConstantAsMetadata>(MD) &&((isa<ConstantAsMetadata>(MD) && "Expected non-function-local metadata"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1100, __PRETTY_FUNCTION__))
             "Expected non-function-local metadata")((isa<ConstantAsMetadata>(MD) && "Expected non-function-local metadata"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantAsMetadata>(MD) && \"Expected non-function-local metadata\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1100, __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");

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

  MetadataList.assignValue(
      ValueAsMetadata::get(ValueList.getValueFwdRef(Record[1], Ty)),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_DISTINCT_NODE:
  IsDistinct = true;
  LLVM_FALLTHROUGH[[clang::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)
  switch (Record[0] >> 1) {
  case 0:
    Val = GET_OR_DISTINCT(DISubrange,
                          (Context, Record[1], unrotateSign(Record.back())));
    break;
  case 1:
    Val = GET_OR_DISTINCT(DISubrange, (Context, getMDOrNull(Record[1]),
                                       unrotateSign(Record.back())));
    break;
  default:
    return error("Invalid record: Unsupported version of DISubrange");
  }

  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;
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIEnumerator, (Context, unrotateSign(Record[1]),
                                     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_DERIVED_TYPE: {
  if (Record.size() < 12 || Record.size() > 13)
    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;

  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]))),
      NextMetadataNo);
  NextMetadataNo++;
  break;
}
case bitc::METADATA_COMPOSITE_TYPE: {
  if (Record.size() < 16 || Record.size() > 17)
    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;
  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;
  } 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]);
  }
  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);

  // 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));
  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() != 6)
    return error("Invalid record");

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DIModule,
                      (Context, getMDOrNull(Record[1]),
                       getMDString(Record[2]), getMDString(Record[3]),
                       getMDString(Record[4]), getMDString(Record[5]))),
      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() > 19)
    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 ? 0 : Record[19]);

  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],
                  /*DIFlagMainSubprogram*/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;
  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;
  }
  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
       ));
  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)
    return error("Invalid record");

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

  IsDistinct = Record[0];
  MetadataList.assignValue(
      GET_OR_DISTINCT(DITemplateValueParameter,
                      (Context, Record[1], getMDString(Record[2]),
                       getDITypeRefOrNull(Record[3]),
                       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) {
    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])),
        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])),
        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));

    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;
  if (HasAlignment) {
    if (Record[8 + HasTag] > (uint64_t)std::numeric_limits<uint32_t>::max())
      return error("Alignment value is too large");
    AlignInBits = Record[8 + HasTag];
  }
  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)),
      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() != 7)
    return error("Invalid record");

  IsDistinct = Record[0];
  bool HasFile = (Record.size() == 7);
  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]))),
      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;
}
}
return Error::success();
1839#undef GET_OR_DISTINCT
1840}

1842Error 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");

  unsigned Size = R.ReadVBR(6);
  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();
1875}

1877Error MetadataLoader::MetadataLoaderImpl::parseGlobalObjectAttachment(
  GlobalObject &GO, ArrayRef<uint64_t> Record) {
assert(Record.size() % 2 == 0)((Record.size() % 2 == 0) ? static_cast<void> (0) : __assert_fail
 ("Record.size() % 2 == 0", "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1879, __PRETTY_FUNCTION__));
for (unsigned I = 0, E = Record.size(); I != E; I += 2) {
  auto K = MDKindMap.find(Record[I]);
  if (K == MDKindMap.end())
    return error("Invalid ID");
  MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(Record[I + 1]);
  if (!MD)
    return error("Invalid metadata attachment: expect fwd ref to MDNode");
  GO.addMetadata(K->second, *MD);
}
return Error::success();
1890}

1892/// Parse metadata attachments.
1893Error MetadataLoader::MetadataLoaderImpl::parseMetadataAttachment(
  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;
PlaceholderQueue Placeholders;

while (true) {
  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

  switch (Entry.Kind) {
  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;
  }

  // Read a metadata attachment record.
  Record.clear();
  ++NumMDRecordLoaded;
  switch (Stream.readRecord(Entry.ID, Record)) {
  default: // Default behavior: ignore.
    break;
  case bitc::METADATA_ATTACHMENT: {
    unsigned RecordLength = Record.size();
    if (Record.empty())
      return error("Invalid record");
    if (RecordLength % 2 == 0) {
      // A function attachment.
      if (Error Err = parseGlobalObjectAttachment(F, Record))
        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")((!MD->isTemporary() && "should load MDs before attachments"
) ? static_cast<void> (0) : __assert_fail ("!MD->isTemporary() && \"should load MDs before attachments\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Bitcode/Reader/MetadataLoader.cpp"
, 1965, __PRETTY_FUNCTION__));
        MD = UpgradeTBAANode(*MD);
      }
      Inst->setMetadata(I->second, MD);
    }
    break;
  }
  }
}
1974}

1976/// Parse a single METADATA_KIND record, inserting result in MDKindMap.
1977Error 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();
1989}

1991/// Parse the metadata kinds out of the METADATA_KIND_BLOCK.
1992Error MetadataLoader::MetadataLoaderImpl::parseMetadataKinds() {
if (Stream.EnterSubBlock(bitc::METADATA_KIND_BLOCK_ID))
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

// Read all the records.
while (true) {
4
←
Loop condition is true.  Entering loop body→
  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
5
←
Calling 'BitstreamCursor::advanceSkippingSubblocks'→

  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;
  unsigned Code = Stream.readRecord(Entry.ID, Record);
  switch (Code) {
  default: // Default behavior: ignore.
    break;
  case bitc::METADATA_KIND: {
    if (Error Err = parseMetadataKindRecord(Record))
      return Err;
    break;
  }
  }
}
2027}

2029MetadataLoader &MetadataLoader::operator=(MetadataLoader &&RHS) {
Pimpl = std::move(RHS.Pimpl);
return *this;
2032}
2033MetadataLoader::MetadataLoader(MetadataLoader &&RHS)
  : Pimpl(std::move(RHS.Pimpl)) {}

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

2044Error MetadataLoader::parseMetadata(bool ModuleLevel) {
return Pimpl->parseMetadata(ModuleLevel);
2046}

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

2050/// Return the given metadata, creating a replaceable forward reference if
2051/// necessary.
2052Metadata *MetadataLoader::getMetadataFwdRefOrLoad(unsigned Idx) {
return Pimpl->getMetadataFwdRefOrLoad(Idx);
2054}

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

2060Error MetadataLoader::parseMetadataAttachment(
  Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
return Pimpl->parseMetadataAttachment(F, InstructionList);
2063}

2065Error MetadataLoader::parseMetadataKinds() {
return Pimpl->parseMetadataKinds();
1
Calling 'MetadataLoaderImpl::parseMetadataKinds'→
2067}

2069void MetadataLoader::setStripTBAA(bool StripTBAA) {
return Pimpl->setStripTBAA(StripTBAA);
2071}

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

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

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

←

/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h

1//===- BitstreamReader.h - Low-level bitstream reader interface -*- 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 header defines the BitstreamReader class.  This class can be used to
10// read an arbitrary bitstream, regardless of its contents.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_BITCODE_BITSTREAMREADER_H
15#define LLVM_BITCODE_BITSTREAMREADER_H

17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Bitcode/BitCodes.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/MemoryBuffer.h"
24#include <algorithm>
25#include <cassert>
26#include <climits>
27#include <cstddef>
28#include <cstdint>
29#include <memory>
30#include <string>
31#include <utility>
32#include <vector>

34namespace llvm {

36/// This class maintains the abbreviations read from a block info block.
37class BitstreamBlockInfo {
38public:
/// This contains information emitted to BLOCKINFO_BLOCK blocks. These
/// describe abbreviations that all blocks of the specified ID inherit.
struct BlockInfo {
  unsigned BlockID;
  std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
  std::string Name;
  std::vector<std::pair<unsigned, std::string>> RecordNames;
};

48private:
std::vector<BlockInfo> BlockInfoRecords;

51public:
/// If there is block info for the specified ID, return it, otherwise return
/// null.
const BlockInfo *getBlockInfo(unsigned BlockID) const {
  // Common case, the most recent entry matches BlockID.
  if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
    return &BlockInfoRecords.back();

  for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
       i != e; ++i)
    if (BlockInfoRecords[i].BlockID == BlockID)
      return &BlockInfoRecords[i];
  return nullptr;
}

BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
  if (const BlockInfo *BI = getBlockInfo(BlockID))
    return *const_cast<BlockInfo*>(BI);

  // Otherwise, add a new record.
  BlockInfoRecords.emplace_back();
  BlockInfoRecords.back().BlockID = BlockID;
  return BlockInfoRecords.back();
}
75};

77/// This represents a position within a bitstream. There may be multiple
78/// independent cursors reading within one bitstream, each maintaining their
79/// own local state.
80class SimpleBitstreamCursor {
ArrayRef<uint8_t> BitcodeBytes;
size_t NextChar = 0;

84public:
/// This is the current data we have pulled from the stream but have not
/// returned to the client. This is specifically and intentionally defined to
/// follow the word size of the host machine for efficiency. We use word_t in
/// places that are aware of this to make it perfectly explicit what is going
/// on.
using word_t = size_t;

92private:
word_t CurWord = 0;

/// This is the number of bits in CurWord that are valid. This is always from
/// [0...bits_of(size_t)-1] inclusive.
unsigned BitsInCurWord = 0;

99public:
static const size_t MaxChunkSize = sizeof(word_t) * 8;

SimpleBitstreamCursor() = default;
explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
    : BitcodeBytes(BitcodeBytes) {}
explicit SimpleBitstreamCursor(StringRef BitcodeBytes)
    : BitcodeBytes(arrayRefFromStringRef(BitcodeBytes)) {}
explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes)
    : SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {}

bool canSkipToPos(size_t pos) const {
  // pos can be skipped to if it is a valid address or one byte past the end.
  return pos <= BitcodeBytes.size();
}

bool AtEndOfStream() {
  return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
}

/// Return the bit # of the bit we are reading.
uint64_t GetCurrentBitNo() const {
  return NextChar*CHAR_BIT8 - BitsInCurWord;
}

// Return the byte # of the current bit.
uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }

ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }

/// Reset the stream to the specified bit number.
void JumpToBit(uint64_t BitNo) {
  size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1);
  unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
  assert(canSkipToPos(ByteNo) && "Invalid location")((canSkipToPos(ByteNo) && "Invalid location") ? static_cast
<void> (0) : __assert_fail ("canSkipToPos(ByteNo) && \"Invalid location\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 133, __PRETTY_FUNCTION__));

  // Move the cursor to the right word.
  NextChar = ByteNo;
  BitsInCurWord = 0;

  // Skip over any bits that are already consumed.
  if (WordBitNo)
    Read(WordBitNo);
}

/// Get a pointer into the bitstream at the specified byte offset.
const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
  return BitcodeBytes.data() + ByteNo;
}

/// Get a pointer into the bitstream at the specified bit offset.
///
/// The bit offset must be on a byte boundary.
const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
  assert(!(BitNo % 8) && "Expected bit on byte boundary")((!(BitNo % 8) && "Expected bit on byte boundary") ? static_cast
<void> (0) : __assert_fail ("!(BitNo % 8) && \"Expected bit on byte boundary\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 153, __PRETTY_FUNCTION__));
  return getPointerToByte(BitNo / 8, NumBytes);
}

void fillCurWord() {
  if (NextChar >= BitcodeBytes.size())
    report_fatal_error("Unexpected end of file");

  // Read the next word from the stream.
  const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
  unsigned BytesRead;
  if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
    BytesRead = sizeof(word_t);
    CurWord =
        support::endian::read<word_t, support::little, support::unaligned>(
            NextCharPtr);
  } else {
    // Short read.
    BytesRead = BitcodeBytes.size() - NextChar;
    CurWord = 0;
    for (unsigned B = 0; B != BytesRead; ++B)
      CurWord |= uint64_t(NextCharPtr[B]) << (B * 8);
  }
  NextChar += BytesRead;
  BitsInCurWord = BytesRead * 8;
}

word_t Read(unsigned NumBits) {
  static const unsigned BitsInWord = MaxChunkSize;

  assert(NumBits && NumBits <= BitsInWord &&((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__))
12
←
Assuming 'NumBits' is not equal to 0→
13
←
Assuming 'NumBits' is <= 'BitsInWord'→
14
←
'?' condition is true→
         "Cannot return zero or more than BitsInWord bits!")((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__));

  static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f;
15
←
'?' condition is true→

  // If the field is fully contained by CurWord, return it quickly.
  if (BitsInCurWord >= NumBits) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
    word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits));

    // Use a mask to avoid undefined behavior.
    CurWord >>= (NumBits & Mask);

    BitsInCurWord -= NumBits;
    return R;
  }

  word_t R = BitsInCurWord ? CurWord : 0;
18
←
'?' condition is true→
  unsigned BitsLeft = NumBits - BitsInCurWord;

  fillCurWord();

  // If we run out of data, abort.
  if (BitsLeft > BitsInCurWord)
19
←
Assuming the condition is false→
20
←
Taking false branch→
    report_fatal_error("Unexpected end of file");

  word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
21
←
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

  // Use a mask to avoid undefined behavior.
  CurWord >>= (BitsLeft & Mask);

  BitsInCurWord -= BitsLeft;

  R |= R2 << (NumBits - BitsLeft);

  return R;
}

uint32_t ReadVBR(unsigned NumBits) {
  uint32_t Piece = Read(NumBits);
  if ((Piece & (1U << (NumBits-1))) == 0)
    return Piece;

  uint32_t Result = 0;
  unsigned NextBit = 0;
  while (true) {
    Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;

    if ((Piece & (1U << (NumBits-1))) == 0)
      return Result;

    NextBit += NumBits-1;
    Piece = Read(NumBits);
  }
}

// Read a VBR that may have a value up to 64-bits in size. The chunk size of
// the VBR must still be <= 32 bits though.
uint64_t ReadVBR64(unsigned NumBits) {
  uint32_t Piece = Read(NumBits);
  if ((Piece & (1U << (NumBits-1))) == 0)
    return uint64_t(Piece);

  uint64_t Result = 0;
  unsigned NextBit = 0;
  while (true) {
    Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;

    if ((Piece & (1U << (NumBits-1))) == 0)
      return Result;

    NextBit += NumBits-1;
    Piece = Read(NumBits);
  }
}

void SkipToFourByteBoundary() {
  // If word_t is 64-bits and if we've read less than 32 bits, just dump
  // the bits we have up to the next 32-bit boundary.
  if (sizeof(word_t) > 4 &&
      BitsInCurWord >= 32) {
    CurWord >>= BitsInCurWord-32;
    BitsInCurWord = 32;
    return;
  }

  BitsInCurWord = 0;
}

/// Skip to the end of the file.
void skipToEnd() { NextChar = BitcodeBytes.size(); }
273};

275/// When advancing through a bitstream cursor, each advance can discover a few
276/// different kinds of entries:
277struct BitstreamEntry {
enum {
  Error,    // Malformed bitcode was found.
  EndBlock, // We've reached the end of the current block, (or the end of the
            // file, which is treated like a series of EndBlock records.
  SubBlock, // This is the start of a new subblock of a specific ID.
  Record    // This is a record with a specific AbbrevID.
} Kind;

unsigned ID;

static BitstreamEntry getError() {
  BitstreamEntry E; E.Kind = Error; return E;
}

static BitstreamEntry getEndBlock() {
  BitstreamEntry E; E.Kind = EndBlock; return E;
}

static BitstreamEntry getSubBlock(unsigned ID) {
  BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
}

static BitstreamEntry getRecord(unsigned AbbrevID) {
  BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
}
303};

305/// This represents a position within a bitcode file, implemented on top of a
306/// SimpleBitstreamCursor.
307///
308/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
309/// be passed by value.
310class BitstreamCursor : SimpleBitstreamCursor {
// This is the declared size of code values used for the current block, in
// bits.
unsigned CurCodeSize = 2;

/// Abbrevs installed at in this block.
std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;

struct Block {
  unsigned PrevCodeSize;
  std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;

  explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
};

/// This tracks the codesize of parent blocks.
SmallVector<Block, 8> BlockScope;

BitstreamBlockInfo *BlockInfo = nullptr;

330public:
static const size_t MaxChunkSize = sizeof(word_t) * 8;

BitstreamCursor() = default;
explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
    : SimpleBitstreamCursor(BitcodeBytes) {}
explicit BitstreamCursor(StringRef BitcodeBytes)
    : SimpleBitstreamCursor(BitcodeBytes) {}
explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
    : SimpleBitstreamCursor(BitcodeBytes) {}

using SimpleBitstreamCursor::canSkipToPos;
using SimpleBitstreamCursor::AtEndOfStream;
using SimpleBitstreamCursor::getBitcodeBytes;
using SimpleBitstreamCursor::GetCurrentBitNo;
using SimpleBitstreamCursor::getCurrentByteNo;
using SimpleBitstreamCursor::getPointerToByte;
using SimpleBitstreamCursor::JumpToBit;
using SimpleBitstreamCursor::fillCurWord;
using SimpleBitstreamCursor::Read;
using SimpleBitstreamCursor::ReadVBR;
using SimpleBitstreamCursor::ReadVBR64;

/// Return the number of bits used to encode an abbrev #.
unsigned getAbbrevIDWidth() const { return CurCodeSize; }

/// Flags that modify the behavior of advance().
enum {
  /// If this flag is used, the advance() method does not automatically pop
  /// the block scope when the end of a block is reached.
  AF_DontPopBlockAtEnd = 1,

  /// If this flag is used, abbrev entries are returned just like normal
  /// records.
  AF_DontAutoprocessAbbrevs = 2
};

/// Advance the current bitstream, returning the next entry in the stream.
BitstreamEntry advance(unsigned Flags = 0) {
  while (true) {
8
←
Loop condition is true.  Entering loop body→
    if (AtEndOfStream())
9
←
Taking false branch→
      return BitstreamEntry::getError();

    unsigned Code = ReadCode();
10
←
Calling 'BitstreamCursor::ReadCode'→
    if (Code == bitc::END_BLOCK) {
      // Pop the end of the block unless Flags tells us not to.
      if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
        return BitstreamEntry::getError();
      return BitstreamEntry::getEndBlock();
    }

    if (Code == bitc::ENTER_SUBBLOCK)
      return BitstreamEntry::getSubBlock(ReadSubBlockID());

    if (Code == bitc::DEFINE_ABBREV &&
        !(Flags & AF_DontAutoprocessAbbrevs)) {
      // We read and accumulate abbrev's, the client can't do anything with
      // them anyway.
      ReadAbbrevRecord();
      continue;
    }

    return BitstreamEntry::getRecord(Code);
  }
}

/// This is a convenience function for clients that don't expect any
/// subblocks. This just skips over them automatically.
BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
  while (true) {
6
←
Loop condition is true.  Entering loop body→
    // If we found a normal entry, return it.
    BitstreamEntry Entry = advance(Flags);
7
←
Calling 'BitstreamCursor::advance'→
    if (Entry.Kind != BitstreamEntry::SubBlock)
      return Entry;

    // If we found a sub-block, just skip over it and check the next entry.
    if (SkipBlock())
      return BitstreamEntry::getError();
  }
}

unsigned ReadCode() {
  return Read(CurCodeSize);
11
←
Calling 'SimpleBitstreamCursor::Read'→
}

// Block header:
//    [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]

/// Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
unsigned ReadSubBlockID() {
  return ReadVBR(bitc::BlockIDWidth);
}

/// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
/// of this block. If the block record is malformed, return true.
bool SkipBlock() {
  // Read and ignore the codelen value.  Since we are skipping this block, we
  // don't care what code widths are used inside of it.
  ReadVBR(bitc::CodeLenWidth);
  SkipToFourByteBoundary();
  size_t NumFourBytes = Read(bitc::BlockSizeWidth);

  // Check that the block wasn't partially defined, and that the offset isn't
  // bogus.
  size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
  if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
    return true;

  JumpToBit(SkipTo);
  return false;
}

/// Having read the ENTER_SUBBLOCK abbrevid, enter the block, and return true
/// if the block has an error.
bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr);

bool ReadBlockEnd() {
  if (BlockScope.empty()) return true;

  // Block tail:
  //    [END_BLOCK, <align4bytes>]
  SkipToFourByteBoundary();

  popBlockScope();
  return false;
}

457private:
void popBlockScope() {
  CurCodeSize = BlockScope.back().PrevCodeSize;

  CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
  BlockScope.pop_back();
}

//===--------------------------------------------------------------------===//
// Record Processing
//===--------------------------------------------------------------------===//

469public:
/// Return the abbreviation for the specified AbbrevId.
const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
  unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV;
  if (AbbrevNo >= CurAbbrevs.size())
    report_fatal_error("Invalid abbrev number");
  return CurAbbrevs[AbbrevNo].get();
}

/// Read the current record and discard it, returning the code for the record.
unsigned skipRecord(unsigned AbbrevID);

unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
                    StringRef *Blob = nullptr);

//===--------------------------------------------------------------------===//
// Abbrev Processing
//===--------------------------------------------------------------------===//
void ReadAbbrevRecord();

/// Read and return a block info block from the bitstream. If an error was
/// encountered, return None.
///
/// \param ReadBlockInfoNames Whether to read block/record name information in
/// the BlockInfo block. Only llvm-bcanalyzer uses this.
Optional<BitstreamBlockInfo>
ReadBlockInfoBlock(bool ReadBlockInfoNames = false);

/// Set the block info to be used by this BitstreamCursor to interpret
/// abbreviated records.
void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; }
500};

502} // end llvm namespace

504#endif // LLVM_BITCODE_BITSTREAMREADER_H