/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp

Bug Summary

File:	lib/Bitcode/Reader/BitcodeReader.cpp
Warning:	line 2878, column 3 1st function call argument is an uninitialized value

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 BitcodeReader.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -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-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.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-7~svn326246/build-llvm/lib/Bitcode/Reader -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp

/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp

→

1//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "llvm/Bitcode/BitcodeReader.h"
11#include "MetadataLoader.h"
12#include "ValueList.h"
13#include "llvm/ADT/APFloat.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/ADT/ArrayRef.h"
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/Optional.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallString.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/Triple.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/Bitcode/BitstreamReader.h"
25#include "llvm/Bitcode/LLVMBitCodes.h"
26#include "llvm/IR/Argument.h"
27#include "llvm/IR/Attributes.h"
28#include "llvm/IR/AutoUpgrade.h"
29#include "llvm/IR/BasicBlock.h"
30#include "llvm/IR/CallSite.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/DataLayout.h"
36#include "llvm/IR/DebugInfo.h"
37#include "llvm/IR/DebugInfoMetadata.h"
38#include "llvm/IR/DebugLoc.h"
39#include "llvm/IR/DerivedTypes.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/InstIterator.h"
50#include "llvm/IR/InstrTypes.h"
51#include "llvm/IR/Instruction.h"
52#include "llvm/IR/Instructions.h"
53#include "llvm/IR/Intrinsics.h"
54#include "llvm/IR/LLVMContext.h"
55#include "llvm/IR/Metadata.h"
56#include "llvm/IR/Module.h"
57#include "llvm/IR/ModuleSummaryIndex.h"
58#include "llvm/IR/Operator.h"
59#include "llvm/IR/Type.h"
60#include "llvm/IR/Value.h"
61#include "llvm/IR/Verifier.h"
62#include "llvm/Support/AtomicOrdering.h"
63#include "llvm/Support/Casting.h"
64#include "llvm/Support/CommandLine.h"
65#include "llvm/Support/Compiler.h"
66#include "llvm/Support/Debug.h"
67#include "llvm/Support/Error.h"
68#include "llvm/Support/ErrorHandling.h"
69#include "llvm/Support/ErrorOr.h"
70#include "llvm/Support/ManagedStatic.h"
71#include "llvm/Support/MathExtras.h"
72#include "llvm/Support/MemoryBuffer.h"
73#include "llvm/Support/raw_ostream.h"
74#include <algorithm>
75#include <cassert>
76#include <cstddef>
77#include <cstdint>
78#include <deque>
79#include <map>
80#include <memory>
81#include <set>
82#include <string>
83#include <system_error>
84#include <tuple>
85#include <utility>
86#include <vector>

88using namespace llvm;

90static cl::opt<bool> PrintSummaryGUIDs(
  "print-summary-global-ids", cl::init(false), cl::Hidden,
  cl::desc(
      "Print the global id for each value when reading the module summary"));

95namespace {

97enum {
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
99};

101} // end anonymous namespace

103static Error error(const Twine &Message) {
return make_error<StringError>(
53
←
Calling 'make_error'→
64
←
Returning from 'make_error'→
    Message, make_error_code(BitcodeError::CorruptedBitcode));
31
←
Calling 'make_error_code'→
52
←
Returning from 'make_error_code'→
106}

108/// Helper to read the header common to all bitcode files.
109static bool hasValidBitcodeHeader(BitstreamCursor &Stream) {
// Sniff for the signature.
if (!Stream.canSkipToPos(4) ||
    Stream.Read(8) != 'B' ||
    Stream.Read(8) != 'C' ||
    Stream.Read(4) != 0x0 ||
    Stream.Read(4) != 0xC ||
    Stream.Read(4) != 0xE ||
    Stream.Read(4) != 0xD)
  return false;
return true;
120}

122static Expected<BitstreamCursor> initStream(MemoryBufferRef Buffer) {
const unsigned char *BufPtr = (const unsigned char *)Buffer.getBufferStart();
const unsigned char *BufEnd = BufPtr + Buffer.getBufferSize();

if (Buffer.getBufferSize() & 3)
  return error("Invalid bitcode signature");

// If we have a wrapper header, parse it and ignore the non-bc file contents.
// The magic number is 0x0B17C0DE stored in little endian.
if (isBitcodeWrapper(BufPtr, BufEnd))
  if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true))
    return error("Invalid bitcode wrapper header");

BitstreamCursor Stream(ArrayRef<uint8_t>(BufPtr, BufEnd));
if (!hasValidBitcodeHeader(Stream))
  return error("Invalid bitcode signature");

return std::move(Stream);
140}

142/// Convert a string from a record into an std::string, return true on failure.
143template <typename StrTy>
144static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx,
                          StrTy &Result) {
if (Idx > Record.size())
  return true;

for (unsigned i = Idx, e = Record.size(); i != e; ++i)
  Result += (char)Record[i];
return false;
152}

154// Strip all the TBAA attachment for the module.
155static void stripTBAA(Module *M) {
for (auto &F : *M) {
  if (F.isMaterializable())
    continue;
  for (auto &I : instructions(F))
    I.setMetadata(LLVMContext::MD_tbaa, nullptr);
}
162}

164/// Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the
165/// "epoch" encoded in the bitcode, and return the producer name if any.
166static Expected<std::string> readIdentificationBlock(BitstreamCursor &Stream) {
if (Stream.EnterSubBlock(bitc::IDENTIFICATION_BLOCK_ID))
  return error("Invalid record");

// Read all the records.
SmallVector<uint64_t, 64> Record;

std::string ProducerIdentification;

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

  switch (Entry.Kind) {
  default:
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return ProducerIdentification;
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  unsigned BitCode = Stream.readRecord(Entry.ID, Record);
  switch (BitCode) {
  default: // Default behavior: reject
    return error("Invalid value");
  case bitc::IDENTIFICATION_CODE_STRING: // IDENTIFICATION: [strchr x N]
    convertToString(Record, 0, ProducerIdentification);
    break;
  case bitc::IDENTIFICATION_CODE_EPOCH: { // EPOCH: [epoch#]
    unsigned epoch = (unsigned)Record[0];
    if (epoch != bitc::BITCODE_CURRENT_EPOCH) {
      return error(
        Twine("Incompatible epoch: Bitcode '") + Twine(epoch) +
        "' vs current: '" + Twine(bitc::BITCODE_CURRENT_EPOCH) + "'");
    }
  }
  }
}
208}

210static Expected<std::string> readIdentificationCode(BitstreamCursor &Stream) {
// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
while (true) {
  if (Stream.AtEndOfStream())
    return "";

  BitstreamEntry Entry = Stream.advance();
  switch (Entry.Kind) {
  case BitstreamEntry::EndBlock:
  case BitstreamEntry::Error:
    return error("Malformed block");

  case BitstreamEntry::SubBlock:
    if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID)
      return readIdentificationBlock(Stream);

    // Ignore other sub-blocks.
    if (Stream.SkipBlock())
      return error("Malformed block");
    continue;
  case BitstreamEntry::Record:
    Stream.skipRecord(Entry.ID);
    continue;
  }
}
236}

238static Expected<bool> hasObjCCategoryInModule(BitstreamCursor &Stream) {
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;
// Read all the records for this module.

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:
    return false;
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:
    break; // Default behavior, ignore unknown content.
  case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    // Check for the i386 and other (x86_64, ARM) conventions
    if (S.find("__DATA,__objc_catlist") != std::string::npos ||
        S.find("__OBJC,__category") != std::string::npos)
      return true;
    break;
  }
  }
  Record.clear();
}
llvm_unreachable("Exit infinite loop")::llvm::llvm_unreachable_internal("Exit infinite loop", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 276);
277}

279static Expected<bool> hasObjCCategory(BitstreamCursor &Stream) {
// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
while (true) {
  BitstreamEntry Entry = Stream.advance();

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return false;

  case BitstreamEntry::SubBlock:
    if (Entry.ID == bitc::MODULE_BLOCK_ID)
      return hasObjCCategoryInModule(Stream);

    // Ignore other sub-blocks.
    if (Stream.SkipBlock())
      return error("Malformed block");
    continue;

  case BitstreamEntry::Record:
    Stream.skipRecord(Entry.ID);
    continue;
  }
}
305}

307static Expected<std::string> readModuleTriple(BitstreamCursor &Stream) {
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

std::string Triple;

// Read all the records for this module.
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:
    return Triple;
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  switch (Stream.readRecord(Entry.ID, Record)) {
  default: break;  // Default behavior, ignore unknown content.
  case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    Triple = S;
    break;
  }
  }
  Record.clear();
}
llvm_unreachable("Exit infinite loop")::llvm::llvm_unreachable_internal("Exit infinite loop", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 343);
344}

346static Expected<std::string> readTriple(BitstreamCursor &Stream) {
// We expect a number of well-defined blocks, though we don't necessarily
// need to understand them all.
while (true) {
  BitstreamEntry Entry = Stream.advance();

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return "";

  case BitstreamEntry::SubBlock:
    if (Entry.ID == bitc::MODULE_BLOCK_ID)
      return readModuleTriple(Stream);

    // Ignore other sub-blocks.
    if (Stream.SkipBlock())
      return error("Malformed block");
    continue;

  case BitstreamEntry::Record:
    Stream.skipRecord(Entry.ID);
    continue;
  }
}
372}

374namespace {

376class BitcodeReaderBase {
377protected:
BitcodeReaderBase(BitstreamCursor Stream, StringRef Strtab)
    : Stream(std::move(Stream)), Strtab(Strtab) {
  this->Stream.setBlockInfo(&BlockInfo);
}

BitstreamBlockInfo BlockInfo;
BitstreamCursor Stream;
StringRef Strtab;

/// In version 2 of the bitcode we store names of global values and comdats in
/// a string table rather than in the VST.
bool UseStrtab = false;

Expected<unsigned> parseVersionRecord(ArrayRef<uint64_t> Record);

/// If this module uses a string table, pop the reference to the string table
/// and return the referenced string and the rest of the record. Otherwise
/// just return the record itself.
std::pair<StringRef, ArrayRef<uint64_t>>
readNameFromStrtab(ArrayRef<uint64_t> Record);

bool readBlockInfo();

// Contains an arbitrary and optional string identifying the bitcode producer
std::string ProducerIdentification;

Error error(const Twine &Message);
405};

407} // end anonymous namespace

409Error BitcodeReaderBase::error(const Twine &Message) {
std::string FullMsg = Message.str();
if (!ProducerIdentification.empty())
21
←
Assuming the condition is false→
22
←
Taking false branch→
  FullMsg += " (Producer: '" + ProducerIdentification + "' Reader: 'LLVM " +
             LLVM_VERSION_STRING"7.0.0" "')";
return ::error(FullMsg);
23
←
Calling constructor for 'Twine'→
29
←
Returning from constructor for 'Twine'→
30
←
Calling 'error'→
65
←
Returning from 'error'→
415}

417Expected<unsigned>
418BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t> Record) {
if (Record.empty())
  return error("Invalid record");
unsigned ModuleVersion = Record[0];
if (ModuleVersion > 2)
  return error("Invalid value");
UseStrtab = ModuleVersion >= 2;
return ModuleVersion;
426}

428std::pair<StringRef, ArrayRef<uint64_t>>
429BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t> Record) {
if (!UseStrtab)
  return {"", Record};
// Invalid reference. Let the caller complain about the record being empty.
if (Record[0] + Record[1] > Strtab.size())
  return {"", {}};
return {StringRef(Strtab.data() + Record[0], Record[1]), Record.slice(2)};
436}

438namespace {

440class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
LLVMContext &Context;
Module *TheModule = nullptr;
// Next offset to start scanning for lazy parsing of function bodies.
uint64_t NextUnreadBit = 0;
// Last function offset found in the VST.
uint64_t LastFunctionBlockBit = 0;
bool SeenValueSymbolTable = false;
uint64_t VSTOffset = 0;

std::vector<std::string> SectionTable;
std::vector<std::string> GCTable;

std::vector<Type*> TypeList;
BitcodeReaderValueList ValueList;
Optional<MetadataLoader> MDLoader;
std::vector<Comdat *> ComdatList;
SmallVector<Instruction *, 64> InstructionList;

std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInits;
std::vector<std::pair<GlobalIndirectSymbol *, unsigned>> IndirectSymbolInits;
std::vector<std::pair<Function *, unsigned>> FunctionPrefixes;
std::vector<std::pair<Function *, unsigned>> FunctionPrologues;
std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFns;

/// The set of attributes by index.  Index zero in the file is for null, and
/// is thus not represented here.  As such all indices are off by one.
std::vector<AttributeList> MAttributes;

/// The set of attribute groups.
std::map<unsigned, AttributeList> MAttributeGroups;

/// While parsing a function body, this is a list of the basic blocks for the
/// function.
std::vector<BasicBlock*> FunctionBBs;

// When reading the module header, this list is populated with functions that
// have bodies later in the file.
std::vector<Function*> FunctionsWithBodies;

// When intrinsic functions are encountered which require upgrading they are
// stored here with their replacement function.
using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
UpdatedIntrinsicMap UpgradedIntrinsics;
// Intrinsics which were remangled because of types rename
UpdatedIntrinsicMap RemangledIntrinsics;

// Several operations happen after the module header has been read, but
// before function bodies are processed. This keeps track of whether
// we've done this yet.
bool SeenFirstFunctionBody = false;

/// When function bodies are initially scanned, this map contains info about
/// where to find deferred function body in the stream.
DenseMap<Function*, uint64_t> DeferredFunctionInfo;

/// When Metadata block is initially scanned when parsing the module, we may
/// choose to defer parsing of the metadata. This vector contains info about
/// which Metadata blocks are deferred.
std::vector<uint64_t> DeferredMetadataInfo;

/// These are basic blocks forward-referenced by block addresses.  They are
/// inserted lazily into functions when they're loaded.  The basic block ID is
/// its index into the vector.
DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
std::deque<Function *> BasicBlockFwdRefQueue;

/// Indicates that we are using a new encoding for instruction operands where
/// most operands in the current FUNCTION_BLOCK are encoded relative to the
/// instruction number, for a more compact encoding.  Some instruction
/// operands are not relative to the instruction ID: basic block numbers, and
/// types. Once the old style function blocks have been phased out, we would
/// not need this flag.
bool UseRelativeIDs = false;

/// True if all functions will be materialized, negating the need to process
/// (e.g.) blockaddress forward references.
bool WillMaterializeAllForwardRefs = false;

bool StripDebugInfo = false;
TBAAVerifier TBAAVerifyHelper;

std::vector<std::string> BundleTags;
SmallVector<SyncScope::ID, 8> SSIDs;

525public:
BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
              StringRef ProducerIdentification, LLVMContext &Context);

Error materializeForwardReferencedFunctions();

Error materialize(GlobalValue *GV) override;
Error materializeModule() override;
std::vector<StructType *> getIdentifiedStructTypes() const override;

/// \brief Main interface to parsing a bitcode buffer.
/// \returns true if an error occurred.
Error parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata = false,
                       bool IsImporting = false);

static uint64_t decodeSignRotatedValue(uint64_t V);

/// Materialize any deferred Metadata block.
Error materializeMetadata() override;

void setStripDebugInfo() override;

547private:
std::vector<StructType *> IdentifiedStructTypes;
StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
StructType *createIdentifiedStructType(LLVMContext &Context);

Type *getTypeByID(unsigned ID);

Value *getFnValueByID(unsigned ID, Type *Ty) {
  if (Ty && Ty->isMetadataTy())
    return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
  return ValueList.getValueFwdRef(ID, Ty);
}

Metadata *getFnMetadataByID(unsigned ID) {
  return MDLoader->getMetadataFwdRefOrLoad(ID);
}

BasicBlock *getBasicBlock(unsigned ID) const {
  if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
  return FunctionBBs[ID];
}

AttributeList getAttributes(unsigned i) const {
  if (i-1 < MAttributes.size())
    return MAttributes[i-1];
  return AttributeList();
}

/// Read a value/type pair out of the specified record from slot 'Slot'.
/// Increment Slot past the number of slots used in the record. Return true on
/// failure.
bool getValueTypePair(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
                      unsigned InstNum, Value *&ResVal) {
  if (Slot == Record.size()) return true;
  unsigned ValNo = (unsigned)Record[Slot++];
  // Adjust the ValNo, if it was encoded relative to the InstNum.
  if (UseRelativeIDs)
    ValNo = InstNum - ValNo;
  if (ValNo < InstNum) {
    // If this is not a forward reference, just return the value we already
    // have.
    ResVal = getFnValueByID(ValNo, nullptr);
    return ResVal == nullptr;
  }
  if (Slot == Record.size())
    return true;

  unsigned TypeNo = (unsigned)Record[Slot++];
  ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
  return ResVal == nullptr;
}

/// Read a value out of the specified record from slot 'Slot'. Increment Slot
/// past the number of slots used by the value in the record. Return true if
/// there is an error.
bool popValue(SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
              unsigned InstNum, Type *Ty, Value *&ResVal) {
  if (getValue(Record, Slot, InstNum, Ty, ResVal))
    return true;
  // All values currently take a single record slot.
  ++Slot;
  return false;
}

/// Like popValue, but does not increment the Slot number.
bool getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
              unsigned InstNum, Type *Ty, Value *&ResVal) {
  ResVal = getValue(Record, Slot, InstNum, Ty);
  return ResVal == nullptr;
}

/// Version of getValue that returns ResVal directly, or 0 if there is an
/// error.
Value *getValue(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
                unsigned InstNum, Type *Ty) {
  if (Slot == Record.size()) return nullptr;
  unsigned ValNo = (unsigned)Record[Slot];
  // Adjust the ValNo, if it was encoded relative to the InstNum.
  if (UseRelativeIDs)
    ValNo = InstNum - ValNo;
  return getFnValueByID(ValNo, Ty);
}

/// Like getValue, but decodes signed VBRs.
Value *getValueSigned(SmallVectorImpl<uint64_t> &Record, unsigned Slot,
                      unsigned InstNum, Type *Ty) {
  if (Slot == Record.size()) return nullptr;
  unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
  // Adjust the ValNo, if it was encoded relative to the InstNum.
  if (UseRelativeIDs)
    ValNo = InstNum - ValNo;
  return getFnValueByID(ValNo, Ty);
}

/// Converts alignment exponent (i.e. power of two (or zero)) to the
/// corresponding alignment to use. If alignment is too large, returns
/// a corresponding error code.
Error parseAlignmentValue(uint64_t Exponent, unsigned &Alignment);
Error parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
Error parseModule(uint64_t ResumeBit, bool ShouldLazyLoadMetadata = false);

Error parseComdatRecord(ArrayRef<uint64_t> Record);
Error parseGlobalVarRecord(ArrayRef<uint64_t> Record);
Error parseFunctionRecord(ArrayRef<uint64_t> Record);
Error parseGlobalIndirectSymbolRecord(unsigned BitCode,
                                      ArrayRef<uint64_t> Record);

Error parseAttributeBlock();
Error parseAttributeGroupBlock();
Error parseTypeTable();
Error parseTypeTableBody();
Error parseOperandBundleTags();
Error parseSyncScopeNames();

Expected<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
                              unsigned NameIndex, Triple &TT);
void setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta, Function *F,
                             ArrayRef<uint64_t> Record);
Error parseValueSymbolTable(uint64_t Offset = 0);
Error parseGlobalValueSymbolTable();
Error parseConstants();
Error rememberAndSkipFunctionBodies();
Error rememberAndSkipFunctionBody();
/// Save the positions of the Metadata blocks and skip parsing the blocks.
Error rememberAndSkipMetadata();
Error typeCheckLoadStoreInst(Type *ValType, Type *PtrType);
Error parseFunctionBody(Function *F);
Error globalCleanup();
Error resolveGlobalAndIndirectSymbolInits();
Error parseUseLists();
Error findFunctionInStream(
    Function *F,
    DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);

SyncScope::ID getDecodedSyncScopeID(unsigned Val);
682};

684/// Class to manage reading and parsing function summary index bitcode
685/// files/sections.
686class ModuleSummaryIndexBitcodeReader : public BitcodeReaderBase {
/// The module index built during parsing.
ModuleSummaryIndex &TheIndex;

/// Indicates whether we have encountered a global value summary section
/// yet during parsing.
bool SeenGlobalValSummary = false;

/// Indicates whether we have already parsed the VST, used for error checking.
bool SeenValueSymbolTable = false;

/// Set to the offset of the VST recorded in the MODULE_CODE_VSTOFFSET record.
/// Used to enable on-demand parsing of the VST.
uint64_t VSTOffset = 0;

// Map to save ValueId to ValueInfo association that was recorded in the
// ValueSymbolTable. It is used after the VST is parsed to convert
// call graph edges read from the function summary from referencing
// callees by their ValueId to using the ValueInfo instead, which is how
// they are recorded in the summary index being built.
// We save a GUID which refers to the same global as the ValueInfo, but
// ignoring the linkage, i.e. for values other than local linkage they are
// identical.
DenseMap<unsigned, std::pair<ValueInfo, GlobalValue::GUID>>
    ValueIdToValueInfoMap;

/// Map populated during module path string table parsing, from the
/// module ID to a string reference owned by the index's module
/// path string table, used to correlate with combined index
/// summary records.
DenseMap<uint64_t, StringRef> ModuleIdMap;

/// Original source file name recorded in a bitcode record.
std::string SourceFileName;

/// The string identifier given to this module by the client, normally the
/// path to the bitcode file.
StringRef ModulePath;

/// For per-module summary indexes, the unique numerical identifier given to
/// this module by the client.
unsigned ModuleId;

729public:
ModuleSummaryIndexBitcodeReader(BitstreamCursor Stream, StringRef Strtab,
                                ModuleSummaryIndex &TheIndex,
                                StringRef ModulePath, unsigned ModuleId);

Error parseModule();

736private:
void setValueGUID(uint64_t ValueID, StringRef ValueName,
                  GlobalValue::LinkageTypes Linkage,
                  StringRef SourceFileName);
Error parseValueSymbolTable(
    uint64_t Offset,
    DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
std::vector<ValueInfo> makeRefList(ArrayRef<uint64_t> Record);
std::vector<FunctionSummary::EdgeTy> makeCallList(ArrayRef<uint64_t> Record,
                                                  bool IsOldProfileFormat,
                                                  bool HasProfile,
                                                  bool HasRelBF);
Error parseEntireSummary(unsigned ID);
Error parseModuleStringTable();

std::pair<ValueInfo, GlobalValue::GUID>
getValueInfoFromValueId(unsigned ValueId);

ModuleSummaryIndex::ModuleInfo *addThisModule();
755};

757} // end anonymous namespace

759std::error_code llvm::errorToErrorCodeAndEmitErrors(LLVMContext &Ctx,
                                                  Error Err) {
if (Err) {
  std::error_code EC;
  handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
    EC = EIB.convertToErrorCode();
    Ctx.emitError(EIB.message());
  });
  return EC;
}
return std::error_code();
770}

772BitcodeReader::BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
                           StringRef ProducerIdentification,
                           LLVMContext &Context)
  : BitcodeReaderBase(std::move(Stream), Strtab), Context(Context),
    ValueList(Context) {
this->ProducerIdentification = ProducerIdentification;
778}

780Error BitcodeReader::materializeForwardReferencedFunctions() {
if (WillMaterializeAllForwardRefs)
  return Error::success();

// Prevent recursion.
WillMaterializeAllForwardRefs = true;

while (!BasicBlockFwdRefQueue.empty()) {
  Function *F = BasicBlockFwdRefQueue.front();
  BasicBlockFwdRefQueue.pop_front();
  assert(F && "Expected valid function")(static_cast <bool> (F && "Expected valid function"
) ? void (0) : __assert_fail ("F && \"Expected valid function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 790, __extension__ __PRETTY_FUNCTION__));
  if (!BasicBlockFwdRefs.count(F))
    // Already materialized.
    continue;

  // Check for a function that isn't materializable to prevent an infinite
  // loop.  When parsing a blockaddress stored in a global variable, there
  // isn't a trivial way to check if a function will have a body without a
  // linear search through FunctionsWithBodies, so just check it here.
  if (!F->isMaterializable())
    return error("Never resolved function from blockaddress");

  // Try to materialize F.
  if (Error Err = materialize(F))
    return Err;
}
assert(BasicBlockFwdRefs.empty() && "Function missing from queue")(static_cast <bool> (BasicBlockFwdRefs.empty() &&
 "Function missing from queue") ? void (0) : __assert_fail ("BasicBlockFwdRefs.empty() && \"Function missing from queue\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 806, __extension__ __PRETTY_FUNCTION__));

// Reset state.
WillMaterializeAllForwardRefs = false;
return Error::success();
811}

813//===----------------------------------------------------------------------===//
814//  Helper functions to implement forward reference resolution, etc.
815//===----------------------------------------------------------------------===//

817static bool hasImplicitComdat(size_t Val) {
switch (Val) {
default:
  return false;
case 1:  // Old WeakAnyLinkage
case 4:  // Old LinkOnceAnyLinkage
case 10: // Old WeakODRLinkage
case 11: // Old LinkOnceODRLinkage
  return true;
}
827}

829static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) {
switch (Val) {
default: // Map unknown/new linkages to external
case 0:
  return GlobalValue::ExternalLinkage;
case 2:
  return GlobalValue::AppendingLinkage;
case 3:
  return GlobalValue::InternalLinkage;
case 5:
  return GlobalValue::ExternalLinkage; // Obsolete DLLImportLinkage
case 6:
  return GlobalValue::ExternalLinkage; // Obsolete DLLExportLinkage
case 7:
  return GlobalValue::ExternalWeakLinkage;
case 8:
  return GlobalValue::CommonLinkage;
case 9:
  return GlobalValue::PrivateLinkage;
case 12:
  return GlobalValue::AvailableExternallyLinkage;
case 13:
  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateLinkage
case 14:
  return GlobalValue::PrivateLinkage; // Obsolete LinkerPrivateWeakLinkage
case 15:
  return GlobalValue::ExternalLinkage; // Obsolete LinkOnceODRAutoHideLinkage
case 1: // Old value with implicit comdat.
case 16:
  return GlobalValue::WeakAnyLinkage;
case 10: // Old value with implicit comdat.
case 17:
  return GlobalValue::WeakODRLinkage;
case 4: // Old value with implicit comdat.
case 18:
  return GlobalValue::LinkOnceAnyLinkage;
case 11: // Old value with implicit comdat.
case 19:
  return GlobalValue::LinkOnceODRLinkage;
}
869}

871static FunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags) {
FunctionSummary::FFlags Flags;
Flags.ReadNone = RawFlags & 0x1;
Flags.ReadOnly = (RawFlags >> 1) & 0x1;
Flags.NoRecurse = (RawFlags >> 2) & 0x1;
Flags.ReturnDoesNotAlias = (RawFlags >> 3) & 0x1;
return Flags;
878}

880/// Decode the flags for GlobalValue in the summary.
881static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags,
                                                          uint64_t Version) {
// Summary were not emitted before LLVM 3.9, we don't need to upgrade Linkage
// like getDecodedLinkage() above. Any future change to the linkage enum and
// to getDecodedLinkage() will need to be taken into account here as above.
auto Linkage = GlobalValue::LinkageTypes(RawFlags & 0xF); // 4 bits
RawFlags = RawFlags >> 4;
bool NotEligibleToImport = (RawFlags & 0x1) || Version < 3;
// The Live flag wasn't introduced until version 3. For dead stripping
// to work correctly on earlier versions, we must conservatively treat all
// values as live.
bool Live = (RawFlags & 0x2) || Version < 3;
bool Local = (RawFlags & 0x4);

return GlobalValueSummary::GVFlags(Linkage, NotEligibleToImport, Live, Local);
896}

898static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {
switch (Val) {
default: // Map unknown visibilities to default.
case 0: return GlobalValue::DefaultVisibility;
case 1: return GlobalValue::HiddenVisibility;
case 2: return GlobalValue::ProtectedVisibility;
}
905}

907static GlobalValue::DLLStorageClassTypes
908getDecodedDLLStorageClass(unsigned Val) {
switch (Val) {
default: // Map unknown values to default.
case 0: return GlobalValue::DefaultStorageClass;
case 1: return GlobalValue::DLLImportStorageClass;
case 2: return GlobalValue::DLLExportStorageClass;
}
915}

917static bool getDecodedDSOLocal(unsigned Val) {
switch(Val) {
default: // Map unknown values to preemptable.
case 0:  return false;
case 1:  return true;
}
923}

925static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {
switch (Val) {
  case 0: return GlobalVariable::NotThreadLocal;
  default: // Map unknown non-zero value to general dynamic.
  case 1: return GlobalVariable::GeneralDynamicTLSModel;
  case 2: return GlobalVariable::LocalDynamicTLSModel;
  case 3: return GlobalVariable::InitialExecTLSModel;
  case 4: return GlobalVariable::LocalExecTLSModel;
}
934}

936static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) {
switch (Val) {
  default: // Map unknown to UnnamedAddr::None.
  case 0: return GlobalVariable::UnnamedAddr::None;
  case 1: return GlobalVariable::UnnamedAddr::Global;
  case 2: return GlobalVariable::UnnamedAddr::Local;
}
943}

945static int getDecodedCastOpcode(unsigned Val) {
switch (Val) {
default: return -1;
case bitc::CAST_TRUNC   : return Instruction::Trunc;
case bitc::CAST_ZEXT    : return Instruction::ZExt;
case bitc::CAST_SEXT    : return Instruction::SExt;
case bitc::CAST_FPTOUI  : return Instruction::FPToUI;
case bitc::CAST_FPTOSI  : return Instruction::FPToSI;
case bitc::CAST_UITOFP  : return Instruction::UIToFP;
case bitc::CAST_SITOFP  : return Instruction::SIToFP;
case bitc::CAST_FPTRUNC : return Instruction::FPTrunc;
case bitc::CAST_FPEXT   : return Instruction::FPExt;
case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
case bitc::CAST_BITCAST : return Instruction::BitCast;
case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
}
962}

964static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) {
bool IsFP = Ty->isFPOrFPVectorTy();
// BinOps are only valid for int/fp or vector of int/fp types
if (!IsFP && !Ty->isIntOrIntVectorTy())
  return -1;

switch (Val) {
default:
  return -1;
case bitc::BINOP_ADD:
  return IsFP ? Instruction::FAdd : Instruction::Add;
case bitc::BINOP_SUB:
  return IsFP ? Instruction::FSub : Instruction::Sub;
case bitc::BINOP_MUL:
  return IsFP ? Instruction::FMul : Instruction::Mul;
case bitc::BINOP_UDIV:
  return IsFP ? -1 : Instruction::UDiv;
case bitc::BINOP_SDIV:
  return IsFP ? Instruction::FDiv : Instruction::SDiv;
case bitc::BINOP_UREM:
  return IsFP ? -1 : Instruction::URem;
case bitc::BINOP_SREM:
  return IsFP ? Instruction::FRem : Instruction::SRem;
case bitc::BINOP_SHL:
  return IsFP ? -1 : Instruction::Shl;
case bitc::BINOP_LSHR:
  return IsFP ? -1 : Instruction::LShr;
case bitc::BINOP_ASHR:
  return IsFP ? -1 : Instruction::AShr;
case bitc::BINOP_AND:
  return IsFP ? -1 : Instruction::And;
case bitc::BINOP_OR:
  return IsFP ? -1 : Instruction::Or;
case bitc::BINOP_XOR:
  return IsFP ? -1 : Instruction::Xor;
}
1000}

1002static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val) {
switch (Val) {
default: return AtomicRMWInst::BAD_BINOP;
case bitc::RMW_XCHG: return AtomicRMWInst::Xchg;
case bitc::RMW_ADD: return AtomicRMWInst::Add;
case bitc::RMW_SUB: return AtomicRMWInst::Sub;
case bitc::RMW_AND: return AtomicRMWInst::And;
case bitc::RMW_NAND: return AtomicRMWInst::Nand;
case bitc::RMW_OR: return AtomicRMWInst::Or;
case bitc::RMW_XOR: return AtomicRMWInst::Xor;
case bitc::RMW_MAX: return AtomicRMWInst::Max;
case bitc::RMW_MIN: return AtomicRMWInst::Min;
case bitc::RMW_UMAX: return AtomicRMWInst::UMax;
case bitc::RMW_UMIN: return AtomicRMWInst::UMin;
}
1017}

1019static AtomicOrdering getDecodedOrdering(unsigned Val) {
switch (Val) {
case bitc::ORDERING_NOTATOMIC: return AtomicOrdering::NotAtomic;
case bitc::ORDERING_UNORDERED: return AtomicOrdering::Unordered;
case bitc::ORDERING_MONOTONIC: return AtomicOrdering::Monotonic;
case bitc::ORDERING_ACQUIRE: return AtomicOrdering::Acquire;
case bitc::ORDERING_RELEASE: return AtomicOrdering::Release;
case bitc::ORDERING_ACQREL: return AtomicOrdering::AcquireRelease;
default: // Map unknown orderings to sequentially-consistent.
case bitc::ORDERING_SEQCST: return AtomicOrdering::SequentiallyConsistent;
}
1030}

1032static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {
switch (Val) {
default: // Map unknown selection kinds to any.
case bitc::COMDAT_SELECTION_KIND_ANY:
  return Comdat::Any;
case bitc::COMDAT_SELECTION_KIND_EXACT_MATCH:
  return Comdat::ExactMatch;
case bitc::COMDAT_SELECTION_KIND_LARGEST:
  return Comdat::Largest;
case bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES:
  return Comdat::NoDuplicates;
case bitc::COMDAT_SELECTION_KIND_SAME_SIZE:
  return Comdat::SameSize;
}
1046}

1048static FastMathFlags getDecodedFastMathFlags(unsigned Val) {
FastMathFlags FMF;
if (0 != (Val & bitc::UnsafeAlgebra))
  FMF.setFast();
if (0 != (Val & bitc::AllowReassoc))
  FMF.setAllowReassoc();
if (0 != (Val & bitc::NoNaNs))
  FMF.setNoNaNs();
if (0 != (Val & bitc::NoInfs))
  FMF.setNoInfs();
if (0 != (Val & bitc::NoSignedZeros))
  FMF.setNoSignedZeros();
if (0 != (Val & bitc::AllowReciprocal))
  FMF.setAllowReciprocal();
if (0 != (Val & bitc::AllowContract))
  FMF.setAllowContract(true);
if (0 != (Val & bitc::ApproxFunc))
  FMF.setApproxFunc();
return FMF;
1067}

1069static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val) {
switch (Val) {
case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
}
1074}

1076Type *BitcodeReader::getTypeByID(unsigned ID) {
// The type table size is always specified correctly.
if (ID >= TypeList.size())
  return nullptr;

if (Type *Ty = TypeList[ID])
  return Ty;

// If we have a forward reference, the only possible case is when it is to a
// named struct.  Just create a placeholder for now.
return TypeList[ID] = createIdentifiedStructType(Context);
1087}

1089StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,
                                                    StringRef Name) {
auto *Ret = StructType::create(Context, Name);
IdentifiedStructTypes.push_back(Ret);
return Ret;
1094}

1096StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {
auto *Ret = StructType::create(Context);
IdentifiedStructTypes.push_back(Ret);
return Ret;
1100}

1102//===----------------------------------------------------------------------===//
1103//  Functions for parsing blocks from the bitcode file
1104//===----------------------------------------------------------------------===//

1106static uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
switch (Val) {
case Attribute::EndAttrKinds:
  llvm_unreachable("Synthetic enumerators which should never get here")::llvm::llvm_unreachable_internal("Synthetic enumerators which should never get here"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1109);

case Attribute::None:            return 0;
case Attribute::ZExt:            return 1 << 0;
case Attribute::SExt:            return 1 << 1;
case Attribute::NoReturn:        return 1 << 2;
case Attribute::InReg:           return 1 << 3;
case Attribute::StructRet:       return 1 << 4;
case Attribute::NoUnwind:        return 1 << 5;
case Attribute::NoAlias:         return 1 << 6;
case Attribute::ByVal:           return 1 << 7;
case Attribute::Nest:            return 1 << 8;
case Attribute::ReadNone:        return 1 << 9;
case Attribute::ReadOnly:        return 1 << 10;
case Attribute::NoInline:        return 1 << 11;
case Attribute::AlwaysInline:    return 1 << 12;
case Attribute::OptimizeForSize: return 1 << 13;
case Attribute::StackProtect:    return 1 << 14;
case Attribute::StackProtectReq: return 1 << 15;
case Attribute::Alignment:       return 31 << 16;
case Attribute::NoCapture:       return 1 << 21;
case Attribute::NoRedZone:       return 1 << 22;
case Attribute::NoImplicitFloat: return 1 << 23;
case Attribute::Naked:           return 1 << 24;
case Attribute::InlineHint:      return 1 << 25;
case Attribute::StackAlignment:  return 7 << 26;
case Attribute::ReturnsTwice:    return 1 << 29;
case Attribute::UWTable:         return 1 << 30;
case Attribute::NonLazyBind:     return 1U << 31;
case Attribute::SanitizeAddress: return 1ULL << 32;
case Attribute::MinSize:         return 1ULL << 33;
case Attribute::NoDuplicate:     return 1ULL << 34;
case Attribute::StackProtectStrong: return 1ULL << 35;
case Attribute::SanitizeThread:  return 1ULL << 36;
case Attribute::SanitizeMemory:  return 1ULL << 37;
case Attribute::NoBuiltin:       return 1ULL << 38;
case Attribute::Returned:        return 1ULL << 39;
case Attribute::Cold:            return 1ULL << 40;
case Attribute::Builtin:         return 1ULL << 41;
case Attribute::OptimizeNone:    return 1ULL << 42;
case Attribute::InAlloca:        return 1ULL << 43;
case Attribute::NonNull:         return 1ULL << 44;
case Attribute::JumpTable:       return 1ULL << 45;
case Attribute::Convergent:      return 1ULL << 46;
case Attribute::SafeStack:       return 1ULL << 47;
case Attribute::NoRecurse:       return 1ULL << 48;
case Attribute::InaccessibleMemOnly:         return 1ULL << 49;
case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50;
case Attribute::SwiftSelf:       return 1ULL << 51;
case Attribute::SwiftError:      return 1ULL << 52;
case Attribute::WriteOnly:       return 1ULL << 53;
case Attribute::Speculatable:    return 1ULL << 54;
case Attribute::StrictFP:        return 1ULL << 55;
case Attribute::SanitizeHWAddress: return 1ULL << 56;
case Attribute::Dereferenceable:
  llvm_unreachable("dereferenceable attribute not supported in raw format")::llvm::llvm_unreachable_internal("dereferenceable attribute not supported in raw format"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1164);
  break;
case Attribute::DereferenceableOrNull:
  llvm_unreachable("dereferenceable_or_null attribute not supported in raw "::llvm::llvm_unreachable_internal("dereferenceable_or_null attribute not supported in raw "
 "format", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1168)
                   "format")::llvm::llvm_unreachable_internal("dereferenceable_or_null attribute not supported in raw "
 "format", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1168);
  break;
case Attribute::ArgMemOnly:
  llvm_unreachable("argmemonly attribute not supported in raw format")::llvm::llvm_unreachable_internal("argmemonly attribute not supported in raw format"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1171);
  break;
case Attribute::AllocSize:
  llvm_unreachable("allocsize not supported in raw format")::llvm::llvm_unreachable_internal("allocsize not supported in raw format"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1174);
  break;
}
llvm_unreachable("Unsupported attribute type")::llvm::llvm_unreachable_internal("Unsupported attribute type"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1177);
1178}

1180static void addRawAttributeValue(AttrBuilder &B, uint64_t Val) {
if (!Val) return;

for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
     I = Attribute::AttrKind(I + 1)) {
  if (I == Attribute::Dereferenceable ||
      I == Attribute::DereferenceableOrNull ||
      I == Attribute::ArgMemOnly ||
      I == Attribute::AllocSize)
    continue;
  if (uint64_t A = (Val & getRawAttributeMask(I))) {
    if (I == Attribute::Alignment)
      B.addAlignmentAttr(1ULL << ((A >> 16) - 1));
    else if (I == Attribute::StackAlignment)
      B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));
    else
      B.addAttribute(I);
  }
}
1199}

1201/// \brief This fills an AttrBuilder object with the LLVM attributes that have
1202/// been decoded from the given integer. This function must stay in sync with
1203/// 'encodeLLVMAttributesForBitcode'.
1204static void decodeLLVMAttributesForBitcode(AttrBuilder &B,
                                         uint64_t EncodedAttrs) {
// FIXME: Remove in 4.0.

// The alignment is stored as a 16-bit raw value from bits 31--16.  We shift
// the bits above 31 down by 11 bits.
unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
assert((!Alignment || isPowerOf2_32(Alignment)) &&(static_cast <bool> ((!Alignment || isPowerOf2_32(Alignment
)) && "Alignment must be a power of two.") ? void (0)
 : __assert_fail ("(!Alignment || isPowerOf2_32(Alignment)) && \"Alignment must be a power of two.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1212, __extension__ __PRETTY_FUNCTION__))
       "Alignment must be a power of two.")(static_cast <bool> ((!Alignment || isPowerOf2_32(Alignment
)) && "Alignment must be a power of two.") ? void (0)
 : __assert_fail ("(!Alignment || isPowerOf2_32(Alignment)) && \"Alignment must be a power of two.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1212, __extension__ __PRETTY_FUNCTION__));

if (Alignment)
  B.addAlignmentAttr(Alignment);
addRawAttributeValue(B, ((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
                        (EncodedAttrs & 0xffff));
1218}

1220Error BitcodeReader::parseAttributeBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
  return error("Invalid record");

if (!MAttributes.empty())
  return error("Invalid multiple blocks");

SmallVector<uint64_t, 64> Record;

SmallVector<AttributeList, 8> Attrs;

// 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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:  // Default behavior: ignore.
    break;
  case bitc::PARAMATTR_CODE_ENTRY_OLD: // ENTRY: [paramidx0, attr0, ...]
    // FIXME: Remove in 4.0.
    if (Record.size() & 1)
      return error("Invalid record");

    for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
      AttrBuilder B;
      decodeLLVMAttributesForBitcode(B, Record[i+1]);
      Attrs.push_back(AttributeList::get(Context, Record[i], B));
    }

    MAttributes.push_back(AttributeList::get(Context, Attrs));
    Attrs.clear();
    break;
  case bitc::PARAMATTR_CODE_ENTRY: // ENTRY: [attrgrp0, attrgrp1, ...]
    for (unsigned i = 0, e = Record.size(); i != e; ++i)
      Attrs.push_back(MAttributeGroups[Record[i]]);

    MAttributes.push_back(AttributeList::get(Context, Attrs));
    Attrs.clear();
    break;
  }
}
1274}

1276// Returns Attribute::None on unrecognized codes.
1277static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
switch (Code) {
default:
  return Attribute::None;
case bitc::ATTR_KIND_ALIGNMENT:
  return Attribute::Alignment;
case bitc::ATTR_KIND_ALWAYS_INLINE:
  return Attribute::AlwaysInline;
case bitc::ATTR_KIND_ARGMEMONLY:
  return Attribute::ArgMemOnly;
case bitc::ATTR_KIND_BUILTIN:
  return Attribute::Builtin;
case bitc::ATTR_KIND_BY_VAL:
  return Attribute::ByVal;
case bitc::ATTR_KIND_IN_ALLOCA:
  return Attribute::InAlloca;
case bitc::ATTR_KIND_COLD:
  return Attribute::Cold;
case bitc::ATTR_KIND_CONVERGENT:
  return Attribute::Convergent;
case bitc::ATTR_KIND_INACCESSIBLEMEM_ONLY:
  return Attribute::InaccessibleMemOnly;
case bitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY:
  return Attribute::InaccessibleMemOrArgMemOnly;
case bitc::ATTR_KIND_INLINE_HINT:
  return Attribute::InlineHint;
case bitc::ATTR_KIND_IN_REG:
  return Attribute::InReg;
case bitc::ATTR_KIND_JUMP_TABLE:
  return Attribute::JumpTable;
case bitc::ATTR_KIND_MIN_SIZE:
  return Attribute::MinSize;
case bitc::ATTR_KIND_NAKED:
  return Attribute::Naked;
case bitc::ATTR_KIND_NEST:
  return Attribute::Nest;
case bitc::ATTR_KIND_NO_ALIAS:
  return Attribute::NoAlias;
case bitc::ATTR_KIND_NO_BUILTIN:
  return Attribute::NoBuiltin;
case bitc::ATTR_KIND_NO_CAPTURE:
  return Attribute::NoCapture;
case bitc::ATTR_KIND_NO_DUPLICATE:
  return Attribute::NoDuplicate;
case bitc::ATTR_KIND_NO_IMPLICIT_FLOAT:
  return Attribute::NoImplicitFloat;
case bitc::ATTR_KIND_NO_INLINE:
  return Attribute::NoInline;
case bitc::ATTR_KIND_NO_RECURSE:
  return Attribute::NoRecurse;
case bitc::ATTR_KIND_NON_LAZY_BIND:
  return Attribute::NonLazyBind;
case bitc::ATTR_KIND_NON_NULL:
  return Attribute::NonNull;
case bitc::ATTR_KIND_DEREFERENCEABLE:
  return Attribute::Dereferenceable;
case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL:
  return Attribute::DereferenceableOrNull;
case bitc::ATTR_KIND_ALLOC_SIZE:
  return Attribute::AllocSize;
case bitc::ATTR_KIND_NO_RED_ZONE:
  return Attribute::NoRedZone;
case bitc::ATTR_KIND_NO_RETURN:
  return Attribute::NoReturn;
case bitc::ATTR_KIND_NO_UNWIND:
  return Attribute::NoUnwind;
case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
  return Attribute::OptimizeForSize;
case bitc::ATTR_KIND_OPTIMIZE_NONE:
  return Attribute::OptimizeNone;
case bitc::ATTR_KIND_READ_NONE:
  return Attribute::ReadNone;
case bitc::ATTR_KIND_READ_ONLY:
  return Attribute::ReadOnly;
case bitc::ATTR_KIND_RETURNED:
  return Attribute::Returned;
case bitc::ATTR_KIND_RETURNS_TWICE:
  return Attribute::ReturnsTwice;
case bitc::ATTR_KIND_S_EXT:
  return Attribute::SExt;
case bitc::ATTR_KIND_SPECULATABLE:
  return Attribute::Speculatable;
case bitc::ATTR_KIND_STACK_ALIGNMENT:
  return Attribute::StackAlignment;
case bitc::ATTR_KIND_STACK_PROTECT:
  return Attribute::StackProtect;
case bitc::ATTR_KIND_STACK_PROTECT_REQ:
  return Attribute::StackProtectReq;
case bitc::ATTR_KIND_STACK_PROTECT_STRONG:
  return Attribute::StackProtectStrong;
case bitc::ATTR_KIND_SAFESTACK:
  return Attribute::SafeStack;
case bitc::ATTR_KIND_STRICT_FP:
  return Attribute::StrictFP;
case bitc::ATTR_KIND_STRUCT_RET:
  return Attribute::StructRet;
case bitc::ATTR_KIND_SANITIZE_ADDRESS:
  return Attribute::SanitizeAddress;
case bitc::ATTR_KIND_SANITIZE_HWADDRESS:
  return Attribute::SanitizeHWAddress;
case bitc::ATTR_KIND_SANITIZE_THREAD:
  return Attribute::SanitizeThread;
case bitc::ATTR_KIND_SANITIZE_MEMORY:
  return Attribute::SanitizeMemory;
case bitc::ATTR_KIND_SWIFT_ERROR:
  return Attribute::SwiftError;
case bitc::ATTR_KIND_SWIFT_SELF:
  return Attribute::SwiftSelf;
case bitc::ATTR_KIND_UW_TABLE:
  return Attribute::UWTable;
case bitc::ATTR_KIND_WRITEONLY:
  return Attribute::WriteOnly;
case bitc::ATTR_KIND_Z_EXT:
  return Attribute::ZExt;
}
1392}

1394Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,
                                       unsigned &Alignment) {
// Note: Alignment in bitcode files is incremented by 1, so that zero
// can be used for default alignment.
if (Exponent > Value::MaxAlignmentExponent + 1)
10
←
Assuming the condition is true→
11
←
Taking true branch→
  return error("Invalid alignment value");
12
←
Calling constructor for 'Twine'→
19
←
Returning from constructor for 'Twine'→
20
←
Calling 'BitcodeReaderBase::error'→
66
←
Returning from 'BitcodeReaderBase::error'→
67
←
Returning without writing to 'Alignment'→
Alignment = (1 << static_cast<unsigned>(Exponent)) >> 1;
return Error::success();
1402}

1404Error BitcodeReader::parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind) {
*Kind = getAttrFromCode(Code);
if (*Kind == Attribute::None)
  return error("Unknown attribute kind (" + Twine(Code) + ")");
return Error::success();
1409}

1411Error BitcodeReader::parseAttributeGroupBlock() {
if (Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))
  return error("Invalid record");

if (!MAttributeGroups.empty())
  return error("Invalid multiple blocks");

SmallVector<uint64_t, 64> Record;

// 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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:  // Default behavior: ignore.
    break;
  case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
    if (Record.size() < 3)
      return error("Invalid record");

    uint64_t GrpID = Record[0];
    uint64_t Idx = Record[1]; // Index of the object this attribute refers to.

    AttrBuilder B;
    for (unsigned i = 2, e = Record.size(); i != e; ++i) {
      if (Record[i] == 0) {        // Enum attribute
        Attribute::AttrKind Kind;
        if (Error Err = parseAttrKind(Record[++i], &Kind))
          return Err;

        B.addAttribute(Kind);
      } else if (Record[i] == 1) { // Integer attribute
        Attribute::AttrKind Kind;
        if (Error Err = parseAttrKind(Record[++i], &Kind))
          return Err;
        if (Kind == Attribute::Alignment)
          B.addAlignmentAttr(Record[++i]);
        else if (Kind == Attribute::StackAlignment)
          B.addStackAlignmentAttr(Record[++i]);
        else if (Kind == Attribute::Dereferenceable)
          B.addDereferenceableAttr(Record[++i]);
        else if (Kind == Attribute::DereferenceableOrNull)
          B.addDereferenceableOrNullAttr(Record[++i]);
        else if (Kind == Attribute::AllocSize)
          B.addAllocSizeAttrFromRawRepr(Record[++i]);
      } else {                     // String attribute
        assert((Record[i] == 3 || Record[i] == 4) &&(static_cast <bool> ((Record[i] == 3 || Record[i] == 4)
 && "Invalid attribute group entry") ? void (0) : __assert_fail
 ("(Record[i] == 3 || Record[i] == 4) && \"Invalid attribute group entry\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1471, __extension__ __PRETTY_FUNCTION__))
               "Invalid attribute group entry")(static_cast <bool> ((Record[i] == 3 || Record[i] == 4)
 && "Invalid attribute group entry") ? void (0) : __assert_fail
 ("(Record[i] == 3 || Record[i] == 4) && \"Invalid attribute group entry\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1471, __extension__ __PRETTY_FUNCTION__));
        bool HasValue = (Record[i++] == 4);
        SmallString<64> KindStr;
        SmallString<64> ValStr;

        while (Record[i] != 0 && i != e)
          KindStr += Record[i++];
        assert(Record[i] == 0 && "Kind string not null terminated")(static_cast <bool> (Record[i] == 0 && "Kind string not null terminated"
) ? void (0) : __assert_fail ("Record[i] == 0 && \"Kind string not null terminated\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1478, __extension__ __PRETTY_FUNCTION__));

        if (HasValue) {
          // Has a value associated with it.
          ++i; // Skip the '0' that terminates the "kind" string.
          while (Record[i] != 0 && i != e)
            ValStr += Record[i++];
          assert(Record[i] == 0 && "Value string not null terminated")(static_cast <bool> (Record[i] == 0 && "Value string not null terminated"
) ? void (0) : __assert_fail ("Record[i] == 0 && \"Value string not null terminated\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1485, __extension__ __PRETTY_FUNCTION__));
        }

        B.addAttribute(KindStr.str(), ValStr.str());
      }
    }

    MAttributeGroups[GrpID] = AttributeList::get(Context, Idx, B);
    break;
  }
  }
}
1497}

1499Error BitcodeReader::parseTypeTable() {
if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
  return error("Invalid record");

return parseTypeTableBody();
1504}

1506Error BitcodeReader::parseTypeTableBody() {
if (!TypeList.empty())
  return error("Invalid multiple blocks");

SmallVector<uint64_t, 64> Record;
unsigned NumRecords = 0;

SmallString<64> TypeName;

// Read all the records for this type table.
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:
    if (NumRecords != TypeList.size())
      return error("Malformed block");
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  Type *ResultTy = nullptr;
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:
    return error("Invalid value");
  case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries]
    // TYPE_CODE_NUMENTRY contains a count of the number of types in the
    // type list.  This allows us to reserve space.
    if (Record.size() < 1)
      return error("Invalid record");
    TypeList.resize(Record[0]);
    continue;
  case bitc::TYPE_CODE_VOID:      // VOID
    ResultTy = Type::getVoidTy(Context);
    break;
  case bitc::TYPE_CODE_HALF:     // HALF
    ResultTy = Type::getHalfTy(Context);
    break;
  case bitc::TYPE_CODE_FLOAT:     // FLOAT
    ResultTy = Type::getFloatTy(Context);
    break;
  case bitc::TYPE_CODE_DOUBLE:    // DOUBLE
    ResultTy = Type::getDoubleTy(Context);
    break;
  case bitc::TYPE_CODE_X86_FP80:  // X86_FP80
    ResultTy = Type::getX86_FP80Ty(Context);
    break;
  case bitc::TYPE_CODE_FP128:     // FP128
    ResultTy = Type::getFP128Ty(Context);
    break;
  case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128
    ResultTy = Type::getPPC_FP128Ty(Context);
    break;
  case bitc::TYPE_CODE_LABEL:     // LABEL
    ResultTy = Type::getLabelTy(Context);
    break;
  case bitc::TYPE_CODE_METADATA:  // METADATA
    ResultTy = Type::getMetadataTy(Context);
    break;
  case bitc::TYPE_CODE_X86_MMX:   // X86_MMX
    ResultTy = Type::getX86_MMXTy(Context);
    break;
  case bitc::TYPE_CODE_TOKEN:     // TOKEN
    ResultTy = Type::getTokenTy(Context);
    break;
  case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
    if (Record.size() < 1)
      return error("Invalid record");

    uint64_t NumBits = Record[0];
    if (NumBits < IntegerType::MIN_INT_BITS ||
        NumBits > IntegerType::MAX_INT_BITS)
      return error("Bitwidth for integer type out of range");
    ResultTy = IntegerType::get(Context, NumBits);
    break;
  }
  case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
                                  //          [pointee type, address space]
    if (Record.size() < 1)
      return error("Invalid record");
    unsigned AddressSpace = 0;
    if (Record.size() == 2)
      AddressSpace = Record[1];
    ResultTy = getTypeByID(Record[0]);
    if (!ResultTy ||
        !PointerType::isValidElementType(ResultTy))
      return error("Invalid type");
    ResultTy = PointerType::get(ResultTy, AddressSpace);
    break;
  }
  case bitc::TYPE_CODE_FUNCTION_OLD: {
    // FIXME: attrid is dead, remove it in LLVM 4.0
    // FUNCTION: [vararg, attrid, retty, paramty x N]
    if (Record.size() < 3)
      return error("Invalid record");
    SmallVector<Type*, 8> ArgTys;
    for (unsigned i = 3, e = Record.size(); i != e; ++i) {
      if (Type *T = getTypeByID(Record[i]))
        ArgTys.push_back(T);
      else
        break;
    }

    ResultTy = getTypeByID(Record[2]);
    if (!ResultTy || ArgTys.size() < Record.size()-3)
      return error("Invalid type");

    ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
    break;
  }
  case bitc::TYPE_CODE_FUNCTION: {
    // FUNCTION: [vararg, retty, paramty x N]
    if (Record.size() < 2)
      return error("Invalid record");
    SmallVector<Type*, 8> ArgTys;
    for (unsigned i = 2, e = Record.size(); i != e; ++i) {
      if (Type *T = getTypeByID(Record[i])) {
        if (!FunctionType::isValidArgumentType(T))
          return error("Invalid function argument type");
        ArgTys.push_back(T);
      }
      else
        break;
    }

    ResultTy = getTypeByID(Record[1]);
    if (!ResultTy || ArgTys.size() < Record.size()-2)
      return error("Invalid type");

    ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
    break;
  }
  case bitc::TYPE_CODE_STRUCT_ANON: {  // STRUCT: [ispacked, eltty x N]
    if (Record.size() < 1)
      return error("Invalid record");
    SmallVector<Type*, 8> EltTys;
    for (unsigned i = 1, e = Record.size(); i != e; ++i) {
      if (Type *T = getTypeByID(Record[i]))
        EltTys.push_back(T);
      else
        break;
    }
    if (EltTys.size() != Record.size()-1)
      return error("Invalid type");
    ResultTy = StructType::get(Context, EltTys, Record[0]);
    break;
  }
  case bitc::TYPE_CODE_STRUCT_NAME:   // STRUCT_NAME: [strchr x N]
    if (convertToString(Record, 0, TypeName))
      return error("Invalid record");
    continue;

  case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
    if (Record.size() < 1)
      return error("Invalid record");

    if (NumRecords >= TypeList.size())
      return error("Invalid TYPE table");

    // Check to see if this was forward referenced, if so fill in the temp.
    StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
    if (Res) {
      Res->setName(TypeName);
      TypeList[NumRecords] = nullptr;
    } else  // Otherwise, create a new struct.
      Res = createIdentifiedStructType(Context, TypeName);
    TypeName.clear();

    SmallVector<Type*, 8> EltTys;
    for (unsigned i = 1, e = Record.size(); i != e; ++i) {
      if (Type *T = getTypeByID(Record[i]))
        EltTys.push_back(T);
      else
        break;
    }
    if (EltTys.size() != Record.size()-1)
      return error("Invalid record");
    Res->setBody(EltTys, Record[0]);
    ResultTy = Res;
    break;
  }
  case bitc::TYPE_CODE_OPAQUE: {       // OPAQUE: []
    if (Record.size() != 1)
      return error("Invalid record");

    if (NumRecords >= TypeList.size())
      return error("Invalid TYPE table");

    // Check to see if this was forward referenced, if so fill in the temp.
    StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
    if (Res) {
      Res->setName(TypeName);
      TypeList[NumRecords] = nullptr;
    } else  // Otherwise, create a new struct with no body.
      Res = createIdentifiedStructType(Context, TypeName);
    TypeName.clear();
    ResultTy = Res;
    break;
  }
  case bitc::TYPE_CODE_ARRAY:     // ARRAY: [numelts, eltty]
    if (Record.size() < 2)
      return error("Invalid record");
    ResultTy = getTypeByID(Record[1]);
    if (!ResultTy || !ArrayType::isValidElementType(ResultTy))
      return error("Invalid type");
    ResultTy = ArrayType::get(ResultTy, Record[0]);
    break;
  case bitc::TYPE_CODE_VECTOR:    // VECTOR: [numelts, eltty]
    if (Record.size() < 2)
      return error("Invalid record");
    if (Record[0] == 0)
      return error("Invalid vector length");
    ResultTy = getTypeByID(Record[1]);
    if (!ResultTy || !StructType::isValidElementType(ResultTy))
      return error("Invalid type");
    ResultTy = VectorType::get(ResultTy, Record[0]);
    break;
  }

  if (NumRecords >= TypeList.size())
    return error("Invalid TYPE table");
  if (TypeList[NumRecords])
    return error(
        "Invalid TYPE table: Only named structs can be forward referenced");
  assert(ResultTy && "Didn't read a type?")(static_cast <bool> (ResultTy && "Didn't read a type?"
) ? void (0) : __assert_fail ("ResultTy && \"Didn't read a type?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1737, __extension__ __PRETTY_FUNCTION__));
  TypeList[NumRecords++] = ResultTy;
}
1740}

1742Error BitcodeReader::parseOperandBundleTags() {
if (Stream.EnterSubBlock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID))
  return error("Invalid record");

if (!BundleTags.empty())
  return error("Invalid multiple blocks");

SmallVector<uint64_t, 64> Record;

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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Tags are implicitly mapped to integers by their order.

  if (Stream.readRecord(Entry.ID, Record) != bitc::OPERAND_BUNDLE_TAG)
    return error("Invalid record");

  // OPERAND_BUNDLE_TAG: [strchr x N]
  BundleTags.emplace_back();
  if (convertToString(Record, 0, BundleTags.back()))
    return error("Invalid record");
  Record.clear();
}
1776}

1778Error BitcodeReader::parseSyncScopeNames() {
if (Stream.EnterSubBlock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID))
  return error("Invalid record");

if (!SSIDs.empty())
  return error("Invalid multiple synchronization scope names blocks");

SmallVector<uint64_t, 64> Record;
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:
    if (SSIDs.empty())
      return error("Invalid empty synchronization scope names block");
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Synchronization scope names are implicitly mapped to synchronization
  // scope IDs by their order.

  if (Stream.readRecord(Entry.ID, Record) != bitc::SYNC_SCOPE_NAME)
    return error("Invalid record");

  SmallString<16> SSN;
  if (convertToString(Record, 0, SSN))
    return error("Invalid record");

  SSIDs.push_back(Context.getOrInsertSyncScopeID(SSN));
  Record.clear();
}
1814}

1816/// Associate a value with its name from the given index in the provided record.
1817Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,
                                           unsigned NameIndex, Triple &TT) {
SmallString<128> ValueName;
if (convertToString(Record, NameIndex, ValueName))
  return error("Invalid record");
unsigned ValueID = Record[0];
if (ValueID >= ValueList.size() || !ValueList[ValueID])
  return error("Invalid record");
Value *V = ValueList[ValueID];

StringRef NameStr(ValueName.data(), ValueName.size());
if (NameStr.find_first_of(0) != StringRef::npos)
  return error("Invalid value name");
V->setName(NameStr);
auto *GO = dyn_cast<GlobalObject>(V);
if (GO) {
  if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
    if (TT.supportsCOMDAT())
      GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
    else
      GO->setComdat(nullptr);
  }
}
return V;
1841}

1843/// Helper to note and return the current location, and jump to the given
1844/// offset.
1845static uint64_t jumpToValueSymbolTable(uint64_t Offset,
                                     BitstreamCursor &Stream) {
// Save the current parsing location so we can jump back at the end
// of the VST read.
uint64_t CurrentBit = Stream.GetCurrentBitNo();
Stream.JumpToBit(Offset * 32);
1851#ifndef NDEBUG
// Do some checking if we are in debug mode.
BitstreamEntry Entry = Stream.advance();
assert(Entry.Kind == BitstreamEntry::SubBlock)(static_cast <bool> (Entry.Kind == BitstreamEntry::SubBlock
) ? void (0) : __assert_fail ("Entry.Kind == BitstreamEntry::SubBlock"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1854, __extension__ __PRETTY_FUNCTION__));
assert(Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID)(static_cast <bool> (Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID
) ? void (0) : __assert_fail ("Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 1855, __extension__ __PRETTY_FUNCTION__));
1856#else
// In NDEBUG mode ignore the output so we don't get an unused variable
// warning.
Stream.advance();
1860#endif
return CurrentBit;
1862}

1864void BitcodeReader::setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta,
                                          Function *F,
                                          ArrayRef<uint64_t> Record) {
// Note that we subtract 1 here because the offset is relative to one word
// before the start of the identification or module block, which was
// historically always the start of the regular bitcode header.
uint64_t FuncWordOffset = Record[1] - 1;
uint64_t FuncBitOffset = FuncWordOffset * 32;
DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta;
// Set the LastFunctionBlockBit to point to the last function block.
// Later when parsing is resumed after function materialization,
// we can simply skip that last function block.
if (FuncBitOffset > LastFunctionBlockBit)
  LastFunctionBlockBit = FuncBitOffset;
1878}

1880/// Read a new-style GlobalValue symbol table.
1881Error BitcodeReader::parseGlobalValueSymbolTable() {
unsigned FuncBitcodeOffsetDelta =
    Stream.getAbbrevIDWidth() + bitc::BlockIDWidth;

if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;
while (true) {
  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

  switch (Entry.Kind) {
  case BitstreamEntry::SubBlock:
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return Error::success();
  case BitstreamEntry::Record:
    break;
  }

  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  case bitc::VST_CODE_FNENTRY: // [valueid, offset]
    setDeferredFunctionInfo(FuncBitcodeOffsetDelta,
                            cast<Function>(ValueList[Record[0]]), Record);
    break;
  }
}
1910}

1912/// Parse the value symbol table at either the current parsing location or
1913/// at the given bit offset if provided.
1914Error BitcodeReader::parseValueSymbolTable(uint64_t Offset) {
uint64_t CurrentBit;
// Pass in the Offset to distinguish between calling for the module-level
// VST (where we want to jump to the VST offset) and the function-level
// VST (where we don't).
if (Offset > 0) {
  CurrentBit = jumpToValueSymbolTable(Offset, Stream);
  // If this module uses a string table, read this as a module-level VST.
  if (UseStrtab) {
    if (Error Err = parseGlobalValueSymbolTable())
      return Err;
    Stream.JumpToBit(CurrentBit);
    return Error::success();
  }
  // Otherwise, the VST will be in a similar format to a function-level VST,
  // and will contain symbol names.
}

// Compute the delta between the bitcode indices in the VST (the word offset
// to the word-aligned ENTER_SUBBLOCK for the function block, and that
// expected by the lazy reader. The reader's EnterSubBlock expects to have
// already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and BlockID
// (size BlockIDWidth). Note that we access the stream's AbbrevID width here
// just before entering the VST subblock because: 1) the EnterSubBlock
// changes the AbbrevID width; 2) the VST block is nested within the same
// outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the same
// AbbrevID width before calling EnterSubBlock; and 3) when we want to
// jump to the FUNCTION_BLOCK using this offset later, we don't want
// to rely on the stream's AbbrevID width being that of the MODULE_BLOCK.
unsigned FuncBitcodeOffsetDelta =
    Stream.getAbbrevIDWidth() + bitc::BlockIDWidth;

if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

Triple TT(TheModule->getTargetTriple());

// Read all the records for this value table.
SmallString<128> ValueName;

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:
    if (Offset > 0)
      Stream.JumpToBit(CurrentBit);
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:  // Default behavior: unknown type.
    break;
  case bitc::VST_CODE_ENTRY: {  // VST_CODE_ENTRY: [valueid, namechar x N]
    Expected<Value *> ValOrErr = recordValue(Record, 1, TT);
    if (Error Err = ValOrErr.takeError())
      return Err;
    ValOrErr.get();
    break;
  }
  case bitc::VST_CODE_FNENTRY: {
    // VST_CODE_FNENTRY: [valueid, offset, namechar x N]
    Expected<Value *> ValOrErr = recordValue(Record, 2, TT);
    if (Error Err = ValOrErr.takeError())
      return Err;
    Value *V = ValOrErr.get();

    // Ignore function offsets emitted for aliases of functions in older
    // versions of LLVM.
    if (auto *F = dyn_cast<Function>(V))
      setDeferredFunctionInfo(FuncBitcodeOffsetDelta, F, Record);
    break;
  }
  case bitc::VST_CODE_BBENTRY: {
    if (convertToString(Record, 1, ValueName))
      return error("Invalid record");
    BasicBlock *BB = getBasicBlock(Record[0]);
    if (!BB)
      return error("Invalid record");

    BB->setName(StringRef(ValueName.data(), ValueName.size()));
    ValueName.clear();
    break;
  }
  }
}
2010}

2012/// Decode a signed value stored with the sign bit in the LSB for dense VBR
2013/// encoding.
2014uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {
if ((V & 1) == 0)
  return V >> 1;
if (V != 1)
  return -(V >> 1);
// There is no such thing as -0 with integers.  "-0" really means MININT.
return 1ULL << 63;
2021}

2023/// Resolve all of the initializers for global values and aliases that we can.
2024Error BitcodeReader::resolveGlobalAndIndirectSymbolInits() {
std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInitWorklist;
std::vector<std::pair<GlobalIndirectSymbol *, unsigned>>
    IndirectSymbolInitWorklist;
std::vector<std::pair<Function *, unsigned>> FunctionPrefixWorklist;
std::vector<std::pair<Function *, unsigned>> FunctionPrologueWorklist;
std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFnWorklist;

GlobalInitWorklist.swap(GlobalInits);
IndirectSymbolInitWorklist.swap(IndirectSymbolInits);
FunctionPrefixWorklist.swap(FunctionPrefixes);
FunctionPrologueWorklist.swap(FunctionPrologues);
FunctionPersonalityFnWorklist.swap(FunctionPersonalityFns);

while (!GlobalInitWorklist.empty()) {
  unsigned ValID = GlobalInitWorklist.back().second;
  if (ValID >= ValueList.size()) {
    // Not ready to resolve this yet, it requires something later in the file.
    GlobalInits.push_back(GlobalInitWorklist.back());
  } else {
    if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
      GlobalInitWorklist.back().first->setInitializer(C);
    else
      return error("Expected a constant");
  }
  GlobalInitWorklist.pop_back();
}

while (!IndirectSymbolInitWorklist.empty()) {
  unsigned ValID = IndirectSymbolInitWorklist.back().second;
  if (ValID >= ValueList.size()) {
    IndirectSymbolInits.push_back(IndirectSymbolInitWorklist.back());
  } else {
    Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]);
    if (!C)
      return error("Expected a constant");
    GlobalIndirectSymbol *GIS = IndirectSymbolInitWorklist.back().first;
    if (isa<GlobalAlias>(GIS) && C->getType() != GIS->getType())
      return error("Alias and aliasee types don't match");
    GIS->setIndirectSymbol(C);
  }
  IndirectSymbolInitWorklist.pop_back();
}

while (!FunctionPrefixWorklist.empty()) {
  unsigned ValID = FunctionPrefixWorklist.back().second;
  if (ValID >= ValueList.size()) {
    FunctionPrefixes.push_back(FunctionPrefixWorklist.back());
  } else {
    if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
      FunctionPrefixWorklist.back().first->setPrefixData(C);
    else
      return error("Expected a constant");
  }
  FunctionPrefixWorklist.pop_back();
}

while (!FunctionPrologueWorklist.empty()) {
  unsigned ValID = FunctionPrologueWorklist.back().second;
  if (ValID >= ValueList.size()) {
    FunctionPrologues.push_back(FunctionPrologueWorklist.back());
  } else {
    if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
      FunctionPrologueWorklist.back().first->setPrologueData(C);
    else
      return error("Expected a constant");
  }
  FunctionPrologueWorklist.pop_back();
}

while (!FunctionPersonalityFnWorklist.empty()) {
  unsigned ValID = FunctionPersonalityFnWorklist.back().second;
  if (ValID >= ValueList.size()) {
    FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back());
  } else {
    if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
      FunctionPersonalityFnWorklist.back().first->setPersonalityFn(C);
    else
      return error("Expected a constant");
  }
  FunctionPersonalityFnWorklist.pop_back();
}

return Error::success();
2108}

2110static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
SmallVector<uint64_t, 8> Words(Vals.size());
transform(Vals, Words.begin(),
               BitcodeReader::decodeSignRotatedValue);

return APInt(TypeBits, Words);
2116}

2118Error BitcodeReader::parseConstants() {
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

// Read all the records for this value table.
Type *CurTy = Type::getInt32Ty(Context);
unsigned NextCstNo = ValueList.size();

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:
    if (NextCstNo != ValueList.size())
      return error("Invalid constant reference");

    // Once all the constants have been read, go through and resolve forward
    // references.
    ValueList.resolveConstantForwardRefs();
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  Type *VoidType = Type::getVoidTy(Context);
  Value *V = nullptr;
  unsigned BitCode = Stream.readRecord(Entry.ID, Record);
  switch (BitCode) {
  default:  // Default behavior: unknown constant
  case bitc::CST_CODE_UNDEF:     // UNDEF
    V = UndefValue::get(CurTy);
    break;
  case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
    if (Record.empty())
      return error("Invalid record");
    if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
      return error("Invalid record");
    if (TypeList[Record[0]] == VoidType)
      return error("Invalid constant type");
    CurTy = TypeList[Record[0]];
    continue;  // Skip the ValueList manipulation.
  case bitc::CST_CODE_NULL:      // NULL
    V = Constant::getNullValue(CurTy);
    break;
  case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
    if (!CurTy->isIntegerTy() || Record.empty())
      return error("Invalid record");
    V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
    break;
  case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
    if (!CurTy->isIntegerTy() || Record.empty())
      return error("Invalid record");

    APInt VInt =
        readWideAPInt(Record, cast<IntegerType>(CurTy)->getBitWidth());
    V = ConstantInt::get(Context, VInt);

    break;
  }
  case bitc::CST_CODE_FLOAT: {    // FLOAT: [fpval]
    if (Record.empty())
      return error("Invalid record");
    if (CurTy->isHalfTy())
      V = ConstantFP::get(Context, APFloat(APFloat::IEEEhalf(),
                                           APInt(16, (uint16_t)Record[0])));
    else if (CurTy->isFloatTy())
      V = ConstantFP::get(Context, APFloat(APFloat::IEEEsingle(),
                                           APInt(32, (uint32_t)Record[0])));
    else if (CurTy->isDoubleTy())
      V = ConstantFP::get(Context, APFloat(APFloat::IEEEdouble(),
                                           APInt(64, Record[0])));
    else if (CurTy->isX86_FP80Ty()) {
      // Bits are not stored the same way as a normal i80 APInt, compensate.
      uint64_t Rearrange[2];
      Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
      Rearrange[1] = Record[0] >> 48;
      V = ConstantFP::get(Context, APFloat(APFloat::x87DoubleExtended(),
                                           APInt(80, Rearrange)));
    } else if (CurTy->isFP128Ty())
      V = ConstantFP::get(Context, APFloat(APFloat::IEEEquad(),
                                           APInt(128, Record)));
    else if (CurTy->isPPC_FP128Ty())
      V = ConstantFP::get(Context, APFloat(APFloat::PPCDoubleDouble(),
                                           APInt(128, Record)));
    else
      V = UndefValue::get(CurTy);
    break;
  }

  case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]
    if (Record.empty())
      return error("Invalid record");

    unsigned Size = Record.size();
    SmallVector<Constant*, 16> Elts;

    if (StructType *STy = dyn_cast<StructType>(CurTy)) {
      for (unsigned i = 0; i != Size; ++i)
        Elts.push_back(ValueList.getConstantFwdRef(Record[i],
                                                   STy->getElementType(i)));
      V = ConstantStruct::get(STy, Elts);
    } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
      Type *EltTy = ATy->getElementType();
      for (unsigned i = 0; i != Size; ++i)
        Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
      V = ConstantArray::get(ATy, Elts);
    } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) {
      Type *EltTy = VTy->getElementType();
      for (unsigned i = 0; i != Size; ++i)
        Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy));
      V = ConstantVector::get(Elts);
    } else {
      V = UndefValue::get(CurTy);
    }
    break;
  }
  case bitc::CST_CODE_STRING:    // STRING: [values]
  case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
    if (Record.empty())
      return error("Invalid record");

    SmallString<16> Elts(Record.begin(), Record.end());
    V = ConstantDataArray::getString(Context, Elts,
                                     BitCode == bitc::CST_CODE_CSTRING);
    break;
  }
  case bitc::CST_CODE_DATA: {// DATA: [n x value]
    if (Record.empty())
      return error("Invalid record");

    Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
    if (EltTy->isIntegerTy(8)) {
      SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::get(Context, Elts);
      else
        V = ConstantDataArray::get(Context, Elts);
    } else if (EltTy->isIntegerTy(16)) {
      SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::get(Context, Elts);
      else
        V = ConstantDataArray::get(Context, Elts);
    } else if (EltTy->isIntegerTy(32)) {
      SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::get(Context, Elts);
      else
        V = ConstantDataArray::get(Context, Elts);
    } else if (EltTy->isIntegerTy(64)) {
      SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::get(Context, Elts);
      else
        V = ConstantDataArray::get(Context, Elts);
    } else if (EltTy->isHalfTy()) {
      SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::getFP(Context, Elts);
      else
        V = ConstantDataArray::getFP(Context, Elts);
    } else if (EltTy->isFloatTy()) {
      SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::getFP(Context, Elts);
      else
        V = ConstantDataArray::getFP(Context, Elts);
    } else if (EltTy->isDoubleTy()) {
      SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
      if (isa<VectorType>(CurTy))
        V = ConstantDataVector::getFP(Context, Elts);
      else
        V = ConstantDataArray::getFP(Context, Elts);
    } else {
      return error("Invalid type for value");
    }
    break;
  }
  case bitc::CST_CODE_CE_BINOP: {  // CE_BINOP: [opcode, opval, opval]
    if (Record.size() < 3)
      return error("Invalid record");
    int Opc = getDecodedBinaryOpcode(Record[0], CurTy);
    if (Opc < 0) {
      V = UndefValue::get(CurTy);  // Unknown binop.
    } else {
      Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy);
      Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy);
      unsigned Flags = 0;
      if (Record.size() >= 4) {
        if (Opc == Instruction::Add ||
            Opc == Instruction::Sub ||
            Opc == Instruction::Mul ||
            Opc == Instruction::Shl) {
          if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
            Flags |= OverflowingBinaryOperator::NoSignedWrap;
          if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
            Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
        } else if (Opc == Instruction::SDiv ||
                   Opc == Instruction::UDiv ||
                   Opc == Instruction::LShr ||
                   Opc == Instruction::AShr) {
          if (Record[3] & (1 << bitc::PEO_EXACT))
            Flags |= SDivOperator::IsExact;
        }
      }
      V = ConstantExpr::get(Opc, LHS, RHS, Flags);
    }
    break;
  }
  case bitc::CST_CODE_CE_CAST: {  // CE_CAST: [opcode, opty, opval]
    if (Record.size() < 3)
      return error("Invalid record");
    int Opc = getDecodedCastOpcode(Record[0]);
    if (Opc < 0) {
      V = UndefValue::get(CurTy);  // Unknown cast.
    } else {
      Type *OpTy = getTypeByID(Record[1]);
      if (!OpTy)
        return error("Invalid record");
      Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy);
      V = UpgradeBitCastExpr(Opc, Op, CurTy);
      if (!V) V = ConstantExpr::getCast(Opc, Op, CurTy);
    }
    break;
  }
  case bitc::CST_CODE_CE_INBOUNDS_GEP: // [ty, n x operands]
  case bitc::CST_CODE_CE_GEP: // [ty, n x operands]
  case bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX: { // [ty, flags, n x
                                                   // operands]
    unsigned OpNum = 0;
    Type *PointeeType = nullptr;
    if (BitCode == bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX ||
        Record.size() % 2)
      PointeeType = getTypeByID(Record[OpNum++]);

    bool InBounds = false;
    Optional<unsigned> InRangeIndex;
    if (BitCode == bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX) {
      uint64_t Op = Record[OpNum++];
      InBounds = Op & 1;
      InRangeIndex = Op >> 1;
    } else if (BitCode == bitc::CST_CODE_CE_INBOUNDS_GEP)
      InBounds = true;

    SmallVector<Constant*, 16> Elts;
    while (OpNum != Record.size()) {
      Type *ElTy = getTypeByID(Record[OpNum++]);
      if (!ElTy)
        return error("Invalid record");
      Elts.push_back(ValueList.getConstantFwdRef(Record[OpNum++], ElTy));
    }

    if (PointeeType &&
        PointeeType !=
            cast<PointerType>(Elts[0]->getType()->getScalarType())
                ->getElementType())
      return error("Explicit gep operator type does not match pointee type "
                   "of pointer operand");

    if (Elts.size() < 1)
      return error("Invalid gep with no operands");

    ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
    V = ConstantExpr::getGetElementPtr(PointeeType, Elts[0], Indices,
                                       InBounds, InRangeIndex);
    break;
  }
  case bitc::CST_CODE_CE_SELECT: {  // CE_SELECT: [opval#, opval#, opval#]
    if (Record.size() < 3)
      return error("Invalid record");

    Type *SelectorTy = Type::getInt1Ty(Context);

    // The selector might be an i1 or an <n x i1>
    // Get the type from the ValueList before getting a forward ref.
    if (VectorType *VTy = dyn_cast<VectorType>(CurTy))
      if (Value *V = ValueList[Record[0]])
        if (SelectorTy != V->getType())
          SelectorTy = VectorType::get(SelectorTy, VTy->getNumElements());

    V = ConstantExpr::getSelect(ValueList.getConstantFwdRef(Record[0],
                                                            SelectorTy),
                                ValueList.getConstantFwdRef(Record[1],CurTy),
                                ValueList.getConstantFwdRef(Record[2],CurTy));
    break;
  }
  case bitc::CST_CODE_CE_EXTRACTELT
      : { // CE_EXTRACTELT: [opty, opval, opty, opval]
    if (Record.size() < 3)
      return error("Invalid record");
    VectorType *OpTy =
      dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
    if (!OpTy)
      return error("Invalid record");
    Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
    Constant *Op1 = nullptr;
    if (Record.size() == 4) {
      Type *IdxTy = getTypeByID(Record[2]);
      if (!IdxTy)
        return error("Invalid record");
      Op1 = ValueList.getConstantFwdRef(Record[3], IdxTy);
    } else // TODO: Remove with llvm 4.0
      Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
    if (!Op1)
      return error("Invalid record");
    V = ConstantExpr::getExtractElement(Op0, Op1);
    break;
  }
  case bitc::CST_CODE_CE_INSERTELT
      : { // CE_INSERTELT: [opval, opval, opty, opval]
    VectorType *OpTy = dyn_cast<VectorType>(CurTy);
    if (Record.size() < 3 || !OpTy)
      return error("Invalid record");
    Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
    Constant *Op1 = ValueList.getConstantFwdRef(Record[1],
                                                OpTy->getElementType());
    Constant *Op2 = nullptr;
    if (Record.size() == 4) {
      Type *IdxTy = getTypeByID(Record[2]);
      if (!IdxTy)
        return error("Invalid record");
      Op2 = ValueList.getConstantFwdRef(Record[3], IdxTy);
    } else // TODO: Remove with llvm 4.0
      Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
    if (!Op2)
      return error("Invalid record");
    V = ConstantExpr::getInsertElement(Op0, Op1, Op2);
    break;
  }
  case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval]
    VectorType *OpTy = dyn_cast<VectorType>(CurTy);
    if (Record.size() < 3 || !OpTy)
      return error("Invalid record");
    Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy);
    Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy);
    Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
                                               OpTy->getNumElements());
    Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy);
    V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
    break;
  }
  case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval]
    VectorType *RTy = dyn_cast<VectorType>(CurTy);
    VectorType *OpTy =
      dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
    if (Record.size() < 4 || !RTy || !OpTy)
      return error("Invalid record");
    Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
    Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);
    Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
                                               RTy->getNumElements());
    Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy);
    V = ConstantExpr::getShuffleVector(Op0, Op1, Op2);
    break;
  }
  case bitc::CST_CODE_CE_CMP: {     // CE_CMP: [opty, opval, opval, pred]
    if (Record.size() < 4)
      return error("Invalid record");
    Type *OpTy = getTypeByID(Record[0]);
    if (!OpTy)
      return error("Invalid record");
    Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy);
    Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy);

    if (OpTy->isFPOrFPVectorTy())
      V = ConstantExpr::getFCmp(Record[3], Op0, Op1);
    else
      V = ConstantExpr::getICmp(Record[3], Op0, Op1);
    break;
  }
  // This maintains backward compatibility, pre-asm dialect keywords.
  // FIXME: Remove with the 4.0 release.
  case bitc::CST_CODE_INLINEASM_OLD: {
    if (Record.size() < 2)
      return error("Invalid record");
    std::string AsmStr, ConstrStr;
    bool HasSideEffects = Record[0] & 1;
    bool IsAlignStack = Record[0] >> 1;
    unsigned AsmStrSize = Record[1];
    if (2+AsmStrSize >= Record.size())
      return error("Invalid record");
    unsigned ConstStrSize = Record[2+AsmStrSize];
    if (3+AsmStrSize+ConstStrSize > Record.size())
      return error("Invalid record");

    for (unsigned i = 0; i != AsmStrSize; ++i)
      AsmStr += (char)Record[2+i];
    for (unsigned i = 0; i != ConstStrSize; ++i)
      ConstrStr += (char)Record[3+AsmStrSize+i];
    PointerType *PTy = cast<PointerType>(CurTy);
    V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
                       AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
    break;
  }
  // This version adds support for the asm dialect keywords (e.g.,
  // inteldialect).
  case bitc::CST_CODE_INLINEASM: {
    if (Record.size() < 2)
      return error("Invalid record");
    std::string AsmStr, ConstrStr;
    bool HasSideEffects = Record[0] & 1;
    bool IsAlignStack = (Record[0] >> 1) & 1;
    unsigned AsmDialect = Record[0] >> 2;
    unsigned AsmStrSize = Record[1];
    if (2+AsmStrSize >= Record.size())
      return error("Invalid record");
    unsigned ConstStrSize = Record[2+AsmStrSize];
    if (3+AsmStrSize+ConstStrSize > Record.size())
      return error("Invalid record");

    for (unsigned i = 0; i != AsmStrSize; ++i)
      AsmStr += (char)Record[2+i];
    for (unsigned i = 0; i != ConstStrSize; ++i)
      ConstrStr += (char)Record[3+AsmStrSize+i];
    PointerType *PTy = cast<PointerType>(CurTy);
    V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()),
                       AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
                       InlineAsm::AsmDialect(AsmDialect));
    break;
  }
  case bitc::CST_CODE_BLOCKADDRESS:{
    if (Record.size() < 3)
      return error("Invalid record");
    Type *FnTy = getTypeByID(Record[0]);
    if (!FnTy)
      return error("Invalid record");
    Function *Fn =
      dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
    if (!Fn)
      return error("Invalid record");

    // If the function is already parsed we can insert the block address right
    // away.
    BasicBlock *BB;
    unsigned BBID = Record[2];
    if (!BBID)
      // Invalid reference to entry block.
      return error("Invalid ID");
    if (!Fn->empty()) {
      Function::iterator BBI = Fn->begin(), BBE = Fn->end();
      for (size_t I = 0, E = BBID; I != E; ++I) {
        if (BBI == BBE)
          return error("Invalid ID");
        ++BBI;
      }
      BB = &*BBI;
    } else {
      // Otherwise insert a placeholder and remember it so it can be inserted
      // when the function is parsed.
      auto &FwdBBs = BasicBlockFwdRefs[Fn];
      if (FwdBBs.empty())
        BasicBlockFwdRefQueue.push_back(Fn);
      if (FwdBBs.size() < BBID + 1)
        FwdBBs.resize(BBID + 1);
      if (!FwdBBs[BBID])
        FwdBBs[BBID] = BasicBlock::Create(Context);
      BB = FwdBBs[BBID];
    }
    V = BlockAddress::get(Fn, BB);
    break;
  }
  }

  ValueList.assignValue(V, NextCstNo);
  ++NextCstNo;
}
2592}

2594Error BitcodeReader::parseUseLists() {
if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))
  return error("Invalid record");

// Read all the records.
SmallVector<uint64_t, 64> Record;

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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a use list record.
  Record.clear();
  bool IsBB = false;
  switch (Stream.readRecord(Entry.ID, Record)) {
  default:  // Default behavior: unknown type.
    break;
  case bitc::USELIST_CODE_BB:
    IsBB = true;
    LLVM_FALLTHROUGH[[clang::fallthrough]];
  case bitc::USELIST_CODE_DEFAULT: {
    unsigned RecordLength = Record.size();
    if (RecordLength < 3)
      // Records should have at least an ID and two indexes.
      return error("Invalid record");
    unsigned ID = Record.back();
    Record.pop_back();

    Value *V;
    if (IsBB) {
      assert(ID < FunctionBBs.size() && "Basic block not found")(static_cast <bool> (ID < FunctionBBs.size() &&
 "Basic block not found") ? void (0) : __assert_fail ("ID < FunctionBBs.size() && \"Basic block not found\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 2634, __extension__ __PRETTY_FUNCTION__));
      V = FunctionBBs[ID];
    } else
      V = ValueList[ID];
    unsigned NumUses = 0;
    SmallDenseMap<const Use *, unsigned, 16> Order;
    for (const Use &U : V->materialized_uses()) {
      if (++NumUses > Record.size())
        break;
      Order[&U] = Record[NumUses - 1];
    }
    if (Order.size() != Record.size() || NumUses > Record.size())
      // Mismatches can happen if the functions are being materialized lazily
      // (out-of-order), or a value has been upgraded.
      break;

    V->sortUseList([&](const Use &L, const Use &R) {
      return Order.lookup(&L) < Order.lookup(&R);
    });
    break;
  }
  }
}
2657}

2659/// When we see the block for metadata, remember where it is and then skip it.
2660/// This lets us lazily deserialize the metadata.
2661Error BitcodeReader::rememberAndSkipMetadata() {
// Save the current stream state.
uint64_t CurBit = Stream.GetCurrentBitNo();
DeferredMetadataInfo.push_back(CurBit);

// Skip over the block for now.
if (Stream.SkipBlock())
  return error("Invalid record");
return Error::success();
2670}

2672Error BitcodeReader::materializeMetadata() {
for (uint64_t BitPos : DeferredMetadataInfo) {
  // Move the bit stream to the saved position.
  Stream.JumpToBit(BitPos);
  if (Error Err = MDLoader->parseModuleMetadata())
    return Err;
}

// Upgrade "Linker Options" module flag to "llvm.linker.options" module-level
// metadata.
if (Metadata *Val = TheModule->getModuleFlag("Linker Options")) {
  NamedMDNode *LinkerOpts =
      TheModule->getOrInsertNamedMetadata("llvm.linker.options");
  for (const MDOperand &MDOptions : cast<MDNode>(Val)->operands())
    LinkerOpts->addOperand(cast<MDNode>(MDOptions));
}

DeferredMetadataInfo.clear();
return Error::success();
2691}

2693void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; }

2695/// When we see the block for a function body, remember where it is and then
2696/// skip it.  This lets us lazily deserialize the functions.
2697Error BitcodeReader::rememberAndSkipFunctionBody() {
// Get the function we are talking about.
if (FunctionsWithBodies.empty())
  return error("Insufficient function protos");

Function *Fn = FunctionsWithBodies.back();
FunctionsWithBodies.pop_back();

// Save the current stream state.
uint64_t CurBit = Stream.GetCurrentBitNo();
assert((static_cast <bool> ((DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo
[Fn] == CurBit) && "Mismatch between VST and scanned function offsets"
) ? void (0) : __assert_fail ("(DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) && \"Mismatch between VST and scanned function offsets\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 2709, __extension__ __PRETTY_FUNCTION__))
    (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&(static_cast <bool> ((DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo
[Fn] == CurBit) && "Mismatch between VST and scanned function offsets"
) ? void (0) : __assert_fail ("(DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) && \"Mismatch between VST and scanned function offsets\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 2709, __extension__ __PRETTY_FUNCTION__))
    "Mismatch between VST and scanned function offsets")(static_cast <bool> ((DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo
[Fn] == CurBit) && "Mismatch between VST and scanned function offsets"
) ? void (0) : __assert_fail ("(DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) && \"Mismatch between VST and scanned function offsets\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 2709, __extension__ __PRETTY_FUNCTION__));
DeferredFunctionInfo[Fn] = CurBit;

// Skip over the function block for now.
if (Stream.SkipBlock())
  return error("Invalid record");
return Error::success();
2716}

2718Error BitcodeReader::globalCleanup() {
// Patch the initializers for globals and aliases up.
if (Error Err = resolveGlobalAndIndirectSymbolInits())
  return Err;
if (!GlobalInits.empty() || !IndirectSymbolInits.empty())
  return error("Malformed global initializer set");

// Look for intrinsic functions which need to be upgraded at some point
for (Function &F : *TheModule) {
  MDLoader->upgradeDebugIntrinsics(F);
  Function *NewFn;
  if (UpgradeIntrinsicFunction(&F, NewFn))
    UpgradedIntrinsics[&F] = NewFn;
  else if (auto Remangled = Intrinsic::remangleIntrinsicFunction(&F))
    // Some types could be renamed during loading if several modules are
    // loaded in the same LLVMContext (LTO scenario). In this case we should
    // remangle intrinsics names as well.
    RemangledIntrinsics[&F] = Remangled.getValue();
}

// Look for global variables which need to be renamed.
for (GlobalVariable &GV : TheModule->globals())
  UpgradeGlobalVariable(&GV);

// Force deallocation of memory for these vectors to favor the client that
// want lazy deserialization.
std::vector<std::pair<GlobalVariable *, unsigned>>().swap(GlobalInits);
std::vector<std::pair<GlobalIndirectSymbol *, unsigned>>().swap(
    IndirectSymbolInits);
return Error::success();
2748}

2750/// Support for lazy parsing of function bodies. This is required if we
2751/// either have an old bitcode file without a VST forward declaration record,
2752/// or if we have an anonymous function being materialized, since anonymous
2753/// functions do not have a name and are therefore not in the VST.
2754Error BitcodeReader::rememberAndSkipFunctionBodies() {
Stream.JumpToBit(NextUnreadBit);

if (Stream.AtEndOfStream())
  return error("Could not find function in stream");

if (!SeenFirstFunctionBody)
  return error("Trying to materialize functions before seeing function blocks");

// An old bitcode file with the symbol table at the end would have
// finished the parse greedily.
assert(SeenValueSymbolTable)(static_cast <bool> (SeenValueSymbolTable) ? void (0) :
 __assert_fail ("SeenValueSymbolTable", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 2765, __extension__ __PRETTY_FUNCTION__));

SmallVector<uint64_t, 64> Record;

while (true) {
  BitstreamEntry Entry = Stream.advance();
  switch (Entry.Kind) {
  default:
    return error("Expect SubBlock");
  case BitstreamEntry::SubBlock:
    switch (Entry.ID) {
    default:
      return error("Expect function block");
    case bitc::FUNCTION_BLOCK_ID:
      if (Error Err = rememberAndSkipFunctionBody())
        return Err;
      NextUnreadBit = Stream.GetCurrentBitNo();
      return Error::success();
    }
  }
}
2786}

2788bool BitcodeReaderBase::readBlockInfo() {
Optional<BitstreamBlockInfo> NewBlockInfo = Stream.ReadBlockInfoBlock();
if (!NewBlockInfo)
  return true;
BlockInfo = std::move(*NewBlockInfo);
return false;
2794}

2796Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) {
// v1: [selection_kind, name]
// v2: [strtab_offset, strtab_size, selection_kind]
StringRef Name;
std::tie(Name, Record) = readNameFromStrtab(Record);

if (Record.empty())
  return error("Invalid record");
Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
std::string OldFormatName;
if (!UseStrtab) {
  if (Record.size() < 2)
    return error("Invalid record");
  unsigned ComdatNameSize = Record[1];
  OldFormatName.reserve(ComdatNameSize);
  for (unsigned i = 0; i != ComdatNameSize; ++i)
    OldFormatName += (char)Record[2 + i];
  Name = OldFormatName;
}
Comdat *C = TheModule->getOrInsertComdat(Name);
C->setSelectionKind(SK);
ComdatList.push_back(C);
return Error::success();
2819}

2821Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
// v1: [pointer type, isconst, initid, linkage, alignment, section,
// visibility, threadlocal, unnamed_addr, externally_initialized,
// dllstorageclass, comdat, attributes, preemption specifier] (name in VST)
// v2: [strtab_offset, strtab_size, v1]
StringRef Name;
std::tie(Name, Record) = readNameFromStrtab(Record);

if (Record.size() < 6)
1
Assuming the condition is false→
2
←
Taking false branch→
  return error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
3
←
Assuming 'Ty' is non-null→
4
←
Taking false branch→
  return error("Invalid record");
bool isConstant = Record[1] & 1;
bool explicitType = Record[1] & 2;
unsigned AddressSpace;
if (explicitType) {
5
←
Assuming 'explicitType' is 0→
6
←
Taking false branch→
  AddressSpace = Record[1] >> 2;
} else {
  if (!Ty->isPointerTy())
7
←
Taking false branch→
    return error("Invalid type for value");
  AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
  Ty = cast<PointerType>(Ty)->getElementType();
}

uint64_t RawLinkage = Record[3];
GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
unsigned Alignment;
8
←
'Alignment' declared without an initial value→
if (Error Err = parseAlignmentValue(Record[4], Alignment))
9
←
Calling 'BitcodeReader::parseAlignmentValue'→
68
←
Returning from 'BitcodeReader::parseAlignmentValue'→
69
←
Taking false branch→
  return Err;
std::string Section;
if (Record[5]) {
70
←
Assuming the condition is false→
71
←
Taking false branch→
  if (Record[5] - 1 >= SectionTable.size())
    return error("Invalid ID");
  Section = SectionTable[Record[5] - 1];
}
GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility;
// Local linkage must have default visibility.
if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
72
←
Assuming the condition is false→
  // FIXME: Change to an error if non-default in 4.0.
  Visibility = getDecodedVisibility(Record[6]);

GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;
if (Record.size() > 7)
73
←
Assuming the condition is false→
74
←
Taking false branch→
  TLM = getDecodedThreadLocalMode(Record[7]);

GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
if (Record.size() > 8)
75
←
Assuming the condition is false→
76
←
Taking false branch→
  UnnamedAddr = getDecodedUnnamedAddrType(Record[8]);

bool ExternallyInitialized = false;
if (Record.size() > 9)
77
←
Assuming the condition is false→
78
←
Taking false branch→
  ExternallyInitialized = Record[9];

GlobalVariable *NewGV =
    new GlobalVariable(*TheModule, Ty, isConstant, Linkage, nullptr, Name,
                       nullptr, TLM, AddressSpace, ExternallyInitialized);
NewGV->setAlignment(Alignment);
79
←
1st function call argument is an uninitialized value
if (!Section.empty())
  NewGV->setSection(Section);
NewGV->setVisibility(Visibility);
NewGV->setUnnamedAddr(UnnamedAddr);

if (Record.size() > 10)
  NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));
else
  upgradeDLLImportExportLinkage(NewGV, RawLinkage);

ValueList.push_back(NewGV);

// Remember which value to use for the global initializer.
if (unsigned InitID = Record[2])
  GlobalInits.push_back(std::make_pair(NewGV, InitID - 1));

if (Record.size() > 11) {
  if (unsigned ComdatID = Record[11]) {
    if (ComdatID > ComdatList.size())
      return error("Invalid global variable comdat ID");
    NewGV->setComdat(ComdatList[ComdatID - 1]);
  }
} else if (hasImplicitComdat(RawLinkage)) {
  NewGV->setComdat(reinterpret_cast<Comdat *>(1));
}

if (Record.size() > 12) {
  auto AS = getAttributes(Record[12]).getFnAttributes();
  NewGV->setAttributes(AS);
}

if (Record.size() > 13) {
  NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
}

return Error::success();
2915}

2917Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
// v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
// visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
// prefixdata,  personalityfn, preemption specifier] (name in VST)
// v2: [strtab_offset, strtab_size, v1]
StringRef Name;
std::tie(Name, Record) = readNameFromStrtab(Record);

if (Record.size() < 8)
  return error("Invalid record");
Type *Ty = getTypeByID(Record[0]);
if (!Ty)
  return error("Invalid record");
if (auto *PTy = dyn_cast<PointerType>(Ty))
  Ty = PTy->getElementType();
auto *FTy = dyn_cast<FunctionType>(Ty);
if (!FTy)
  return error("Invalid type for value");
auto CC = static_cast<CallingConv::ID>(Record[1]);
if (CC & ~CallingConv::MaxID)
  return error("Invalid calling convention ID");

Function *Func =
    Function::Create(FTy, GlobalValue::ExternalLinkage, Name, TheModule);

Func->setCallingConv(CC);
bool isProto = Record[2];
uint64_t RawLinkage = Record[3];
Func->setLinkage(getDecodedLinkage(RawLinkage));
Func->setAttributes(getAttributes(Record[4]));

unsigned Alignment;
if (Error Err = parseAlignmentValue(Record[5], Alignment))
  return Err;
Func->setAlignment(Alignment);
if (Record[6]) {
  if (Record[6] - 1 >= SectionTable.size())
    return error("Invalid ID");
  Func->setSection(SectionTable[Record[6] - 1]);
}
// Local linkage must have default visibility.
if (!Func->hasLocalLinkage())
  // FIXME: Change to an error if non-default in 4.0.
  Func->setVisibility(getDecodedVisibility(Record[7]));
if (Record.size() > 8 && Record[8]) {
  if (Record[8] - 1 >= GCTable.size())
    return error("Invalid ID");
  Func->setGC(GCTable[Record[8] - 1]);
}
GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
if (Record.size() > 9)
  UnnamedAddr = getDecodedUnnamedAddrType(Record[9]);
Func->setUnnamedAddr(UnnamedAddr);
if (Record.size() > 10 && Record[10] != 0)
  FunctionPrologues.push_back(std::make_pair(Func, Record[10] - 1));

if (Record.size() > 11)
  Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
else
  upgradeDLLImportExportLinkage(Func, RawLinkage);

if (Record.size() > 12) {
  if (unsigned ComdatID = Record[12]) {
    if (ComdatID > ComdatList.size())
      return error("Invalid function comdat ID");
    Func->setComdat(ComdatList[ComdatID - 1]);
  }
} else if (hasImplicitComdat(RawLinkage)) {
  Func->setComdat(reinterpret_cast<Comdat *>(1));
}

if (Record.size() > 13 && Record[13] != 0)
  FunctionPrefixes.push_back(std::make_pair(Func, Record[13] - 1));

if (Record.size() > 14 && Record[14] != 0)
  FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));

if (Record.size() > 15) {
  Func->setDSOLocal(getDecodedDSOLocal(Record[15]));
}

ValueList.push_back(Func);

// If this is a function with a body, remember the prototype we are
// creating now, so that we can match up the body with them later.
if (!isProto) {
  Func->setIsMaterializable(true);
  FunctionsWithBodies.push_back(Func);
  DeferredFunctionInfo[Func] = 0;
}
return Error::success();
3008}

3010Error BitcodeReader::parseGlobalIndirectSymbolRecord(
  unsigned BitCode, ArrayRef<uint64_t> Record) {
// v1 ALIAS_OLD: [alias type, aliasee val#, linkage] (name in VST)
// v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility,
// dllstorageclass, threadlocal, unnamed_addr,
// preemption specifier] (name in VST)
// v1 IFUNC: [alias type, addrspace, aliasee val#, linkage,
// visibility, dllstorageclass, threadlocal, unnamed_addr,
// preemption specifier] (name in VST)
// v2: [strtab_offset, strtab_size, v1]
StringRef Name;
std::tie(Name, Record) = readNameFromStrtab(Record);

bool NewRecord = BitCode != bitc::MODULE_CODE_ALIAS_OLD;
if (Record.size() < (3 + (unsigned)NewRecord))
  return error("Invalid record");
unsigned OpNum = 0;
Type *Ty = getTypeByID(Record[OpNum++]);
if (!Ty)
  return error("Invalid record");

unsigned AddrSpace;
if (!NewRecord) {
  auto *PTy = dyn_cast<PointerType>(Ty);
  if (!PTy)
    return error("Invalid type for value");
  Ty = PTy->getElementType();
  AddrSpace = PTy->getAddressSpace();
} else {
  AddrSpace = Record[OpNum++];
}

auto Val = Record[OpNum++];
auto Linkage = Record[OpNum++];
GlobalIndirectSymbol *NewGA;
if (BitCode == bitc::MODULE_CODE_ALIAS ||
    BitCode == bitc::MODULE_CODE_ALIAS_OLD)
  NewGA = GlobalAlias::create(Ty, AddrSpace, getDecodedLinkage(Linkage), Name,
                              TheModule);
else
  NewGA = GlobalIFunc::create(Ty, AddrSpace, getDecodedLinkage(Linkage), Name,
                              nullptr, TheModule);
// Old bitcode files didn't have visibility field.
// Local linkage must have default visibility.
if (OpNum != Record.size()) {
  auto VisInd = OpNum++;
  if (!NewGA->hasLocalLinkage())
    // FIXME: Change to an error if non-default in 4.0.
    NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));
}
if (BitCode == bitc::MODULE_CODE_ALIAS ||
    BitCode == bitc::MODULE_CODE_ALIAS_OLD) {
  if (OpNum != Record.size())
    NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
  else
    upgradeDLLImportExportLinkage(NewGA, Linkage);
  if (OpNum != Record.size())
    NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
  if (OpNum != Record.size())
    NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
}
if (OpNum != Record.size())
  NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));
ValueList.push_back(NewGA);
IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
return Error::success();
3076}

3078Error BitcodeReader::parseModule(uint64_t ResumeBit,
                               bool ShouldLazyLoadMetadata) {
if (ResumeBit)
  Stream.JumpToBit(ResumeBit);
else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

// Read all the records for this module.
while (true) {
  BitstreamEntry Entry = Stream.advance();

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return globalCleanup();

  case BitstreamEntry::SubBlock:
    switch (Entry.ID) {
    default:  // Skip unknown content.
      if (Stream.SkipBlock())
        return error("Invalid record");
      break;
    case bitc::BLOCKINFO_BLOCK_ID:
      if (readBlockInfo())
        return error("Malformed block");
      break;
    case bitc::PARAMATTR_BLOCK_ID:
      if (Error Err = parseAttributeBlock())
        return Err;
      break;
    case bitc::PARAMATTR_GROUP_BLOCK_ID:
      if (Error Err = parseAttributeGroupBlock())
        return Err;
      break;
    case bitc::TYPE_BLOCK_ID_NEW:
      if (Error Err = parseTypeTable())
        return Err;
      break;
    case bitc::VALUE_SYMTAB_BLOCK_ID:
      if (!SeenValueSymbolTable) {
        // Either this is an old form VST without function index and an
        // associated VST forward declaration record (which would have caused
        // the VST to be jumped to and parsed before it was encountered
        // normally in the stream), or there were no function blocks to
        // trigger an earlier parsing of the VST.
        assert(VSTOffset == 0 || FunctionsWithBodies.empty())(static_cast <bool> (VSTOffset == 0 || FunctionsWithBodies
.empty()) ? void (0) : __assert_fail ("VSTOffset == 0 || FunctionsWithBodies.empty()"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3126, __extension__ __PRETTY_FUNCTION__));
        if (Error Err = parseValueSymbolTable())
          return Err;
        SeenValueSymbolTable = true;
      } else {
        // We must have had a VST forward declaration record, which caused
        // the parser to jump to and parse the VST earlier.
        assert(VSTOffset > 0)(static_cast <bool> (VSTOffset > 0) ? void (0) : __assert_fail
 ("VSTOffset > 0", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3133, __extension__ __PRETTY_FUNCTION__));
        if (Stream.SkipBlock())
          return error("Invalid record");
      }
      break;
    case bitc::CONSTANTS_BLOCK_ID:
      if (Error Err = parseConstants())
        return Err;
      if (Error Err = resolveGlobalAndIndirectSymbolInits())
        return Err;
      break;
    case bitc::METADATA_BLOCK_ID:
      if (ShouldLazyLoadMetadata) {
        if (Error Err = rememberAndSkipMetadata())
          return Err;
        break;
      }
      assert(DeferredMetadataInfo.empty() && "Unexpected deferred metadata")(static_cast <bool> (DeferredMetadataInfo.empty() &&
 "Unexpected deferred metadata") ? void (0) : __assert_fail (
"DeferredMetadataInfo.empty() && \"Unexpected deferred metadata\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3150, __extension__ __PRETTY_FUNCTION__));
      if (Error Err = MDLoader->parseModuleMetadata())
        return Err;
      break;
    case bitc::METADATA_KIND_BLOCK_ID:
      if (Error Err = MDLoader->parseMetadataKinds())
        return Err;
      break;
    case bitc::FUNCTION_BLOCK_ID:
      // If this is the first function body we've seen, reverse the
      // FunctionsWithBodies list.
      if (!SeenFirstFunctionBody) {
        std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());
        if (Error Err = globalCleanup())
          return Err;
        SeenFirstFunctionBody = true;
      }

      if (VSTOffset > 0) {
        // If we have a VST forward declaration record, make sure we
        // parse the VST now if we haven't already. It is needed to
        // set up the DeferredFunctionInfo vector for lazy reading.
        if (!SeenValueSymbolTable) {
          if (Error Err = BitcodeReader::parseValueSymbolTable(VSTOffset))
            return Err;
          SeenValueSymbolTable = true;
          // Fall through so that we record the NextUnreadBit below.
          // This is necessary in case we have an anonymous function that
          // is later materialized. Since it will not have a VST entry we
          // need to fall back to the lazy parse to find its offset.
        } else {
          // If we have a VST forward declaration record, but have already
          // parsed the VST (just above, when the first function body was
          // encountered here), then we are resuming the parse after
          // materializing functions. The ResumeBit points to the
          // start of the last function block recorded in the
          // DeferredFunctionInfo map. Skip it.
          if (Stream.SkipBlock())
            return error("Invalid record");
          continue;
        }
      }

      // Support older bitcode files that did not have the function
      // index in the VST, nor a VST forward declaration record, as
      // well as anonymous functions that do not have VST entries.
      // Build the DeferredFunctionInfo vector on the fly.
      if (Error Err = rememberAndSkipFunctionBody())
        return Err;

      // Suspend parsing when we reach the function bodies. Subsequent
      // materialization calls will resume it when necessary. If the bitcode
      // file is old, the symbol table will be at the end instead and will not
      // have been seen yet. In this case, just finish the parse now.
      if (SeenValueSymbolTable) {
        NextUnreadBit = Stream.GetCurrentBitNo();
        // After the VST has been parsed, we need to make sure intrinsic name
        // are auto-upgraded.
        return globalCleanup();
      }
      break;
    case bitc::USELIST_BLOCK_ID:
      if (Error Err = parseUseLists())
        return Err;
      break;
    case bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:
      if (Error Err = parseOperandBundleTags())
        return Err;
      break;
    case bitc::SYNC_SCOPE_NAMES_BLOCK_ID:
      if (Error Err = parseSyncScopeNames())
        return Err;
      break;
    }
    continue;

  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  auto BitCode = Stream.readRecord(Entry.ID, Record);
  switch (BitCode) {
  default: break;  // Default behavior, ignore unknown content.
  case bitc::MODULE_CODE_VERSION: {
    Expected<unsigned> VersionOrErr = parseVersionRecord(Record);
    if (!VersionOrErr)
      return VersionOrErr.takeError();
    UseRelativeIDs = *VersionOrErr >= 1;
    break;
  }
  case bitc::MODULE_CODE_TRIPLE: {  // TRIPLE: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    TheModule->setTargetTriple(S);
    break;
  }
  case bitc::MODULE_CODE_DATALAYOUT: {  // DATALAYOUT: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    TheModule->setDataLayout(S);
    break;
  }
  case bitc::MODULE_CODE_ASM: {  // ASM: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    TheModule->setModuleInlineAsm(S);
    break;
  }
  case bitc::MODULE_CODE_DEPLIB: {  // DEPLIB: [strchr x N]
    // FIXME: Remove in 4.0.
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    // Ignore value.
    break;
  }
  case bitc::MODULE_CODE_SECTIONNAME: {  // SECTIONNAME: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    SectionTable.push_back(S);
    break;
  }
  case bitc::MODULE_CODE_GCNAME: {  // SECTIONNAME: [strchr x N]
    std::string S;
    if (convertToString(Record, 0, S))
      return error("Invalid record");
    GCTable.push_back(S);
    break;
  }
  case bitc::MODULE_CODE_COMDAT:
    if (Error Err = parseComdatRecord(Record))
      return Err;
    break;
  case bitc::MODULE_CODE_GLOBALVAR:
    if (Error Err = parseGlobalVarRecord(Record))
      return Err;
    break;
  case bitc::MODULE_CODE_FUNCTION:
    if (Error Err = parseFunctionRecord(Record))
      return Err;
    break;
  case bitc::MODULE_CODE_IFUNC:
  case bitc::MODULE_CODE_ALIAS:
  case bitc::MODULE_CODE_ALIAS_OLD:
    if (Error Err = parseGlobalIndirectSymbolRecord(BitCode, Record))
      return Err;
    break;
  /// MODULE_CODE_VSTOFFSET: [offset]
  case bitc::MODULE_CODE_VSTOFFSET:
    if (Record.size() < 1)
      return error("Invalid record");
    // Note that we subtract 1 here because the offset is relative to one word
    // before the start of the identification or module block, which was
    // historically always the start of the regular bitcode header.
    VSTOffset = Record[0] - 1;
    break;
  /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]
  case bitc::MODULE_CODE_SOURCE_FILENAME:
    SmallString<128> ValueName;
    if (convertToString(Record, 0, ValueName))
      return error("Invalid record");
    TheModule->setSourceFileName(ValueName);
    break;
  }
  Record.clear();
}
3322}

3324Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata,
                                    bool IsImporting) {
TheModule = M;
MDLoader = MetadataLoader(Stream, *M, ValueList, IsImporting,
                          [&](unsigned ID) { return getTypeByID(ID); });
return parseModule(0, ShouldLazyLoadMetadata);
3330}

3332Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
if (!isa<PointerType>(PtrType))
  return error("Load/Store operand is not a pointer type");
Type *ElemType = cast<PointerType>(PtrType)->getElementType();

if (ValType && ValType != ElemType)
  return error("Explicit load/store type does not match pointee "
               "type of pointer operand");
if (!PointerType::isLoadableOrStorableType(ElemType))
  return error("Cannot load/store from pointer");
return Error::success();
3343}

3345/// Lazily parse the specified function body block.
3346Error BitcodeReader::parseFunctionBody(Function *F) {
if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
  return error("Invalid record");

// Unexpected unresolved metadata when parsing function.
if (MDLoader->hasFwdRefs())
  return error("Invalid function metadata: incoming forward references");

InstructionList.clear();
unsigned ModuleValueListSize = ValueList.size();
unsigned ModuleMDLoaderSize = MDLoader->size();

// Add all the function arguments to the value table.
for (Argument &I : F->args())
  ValueList.push_back(&I);

unsigned NextValueNo = ValueList.size();
BasicBlock *CurBB = nullptr;
unsigned CurBBNo = 0;

DebugLoc LastLoc;
auto getLastInstruction = [&]() -> Instruction * {
  if (CurBB && !CurBB->empty())
    return &CurBB->back();
  else if (CurBBNo && FunctionBBs[CurBBNo - 1] &&
           !FunctionBBs[CurBBNo - 1]->empty())
    return &FunctionBBs[CurBBNo - 1]->back();
  return nullptr;
};

std::vector<OperandBundleDef> OperandBundles;

// Read all the records.
SmallVector<uint64_t, 64> Record;

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

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    goto OutOfRecordLoop;

  case BitstreamEntry::SubBlock:
    switch (Entry.ID) {
    default:  // Skip unknown content.
      if (Stream.SkipBlock())
        return error("Invalid record");
      break;
    case bitc::CONSTANTS_BLOCK_ID:
      if (Error Err = parseConstants())
        return Err;
      NextValueNo = ValueList.size();
      break;
    case bitc::VALUE_SYMTAB_BLOCK_ID:
      if (Error Err = parseValueSymbolTable())
        return Err;
      break;
    case bitc::METADATA_ATTACHMENT_ID:
      if (Error Err = MDLoader->parseMetadataAttachment(*F, InstructionList))
        return Err;
      break;
    case bitc::METADATA_BLOCK_ID:
      assert(DeferredMetadataInfo.empty() &&(static_cast <bool> (DeferredMetadataInfo.empty() &&
 "Must read all module-level metadata before function-level")
 ? void (0) : __assert_fail ("DeferredMetadataInfo.empty() && \"Must read all module-level metadata before function-level\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3411, __extension__ __PRETTY_FUNCTION__))
             "Must read all module-level metadata before function-level")(static_cast <bool> (DeferredMetadataInfo.empty() &&
 "Must read all module-level metadata before function-level")
 ? void (0) : __assert_fail ("DeferredMetadataInfo.empty() && \"Must read all module-level metadata before function-level\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3411, __extension__ __PRETTY_FUNCTION__));
      if (Error Err = MDLoader->parseFunctionMetadata())
        return Err;
      break;
    case bitc::USELIST_BLOCK_ID:
      if (Error Err = parseUseLists())
        return Err;
      break;
    }
    continue;

  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  Instruction *I = nullptr;
  unsigned BitCode = Stream.readRecord(Entry.ID, Record);
  switch (BitCode) {
  default: // Default behavior: reject
    return error("Invalid value");
  case bitc::FUNC_CODE_DECLAREBLOCKS: {   // DECLAREBLOCKS: [nblocks]
    if (Record.size() < 1 || Record[0] == 0)
      return error("Invalid record");
    // Create all the basic blocks for the function.
    FunctionBBs.resize(Record[0]);

    // See if anything took the address of blocks in this function.
    auto BBFRI = BasicBlockFwdRefs.find(F);
    if (BBFRI == BasicBlockFwdRefs.end()) {
      for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
        FunctionBBs[i] = BasicBlock::Create(Context, "", F);
    } else {
      auto &BBRefs = BBFRI->second;
      // Check for invalid basic block references.
      if (BBRefs.size() > FunctionBBs.size())
        return error("Invalid ID");
      assert(!BBRefs.empty() && "Unexpected empty array")(static_cast <bool> (!BBRefs.empty() && "Unexpected empty array"
) ? void (0) : __assert_fail ("!BBRefs.empty() && \"Unexpected empty array\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3450, __extension__ __PRETTY_FUNCTION__));
      assert(!BBRefs.front() && "Invalid reference to entry block")(static_cast <bool> (!BBRefs.front() && "Invalid reference to entry block"
) ? void (0) : __assert_fail ("!BBRefs.front() && \"Invalid reference to entry block\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 3451, __extension__ __PRETTY_FUNCTION__));
      for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
           ++I)
        if (I < RE && BBRefs[I]) {
          BBRefs[I]->insertInto(F);
          FunctionBBs[I] = BBRefs[I];
        } else {
          FunctionBBs[I] = BasicBlock::Create(Context, "", F);
        }

      // Erase from the table.
      BasicBlockFwdRefs.erase(BBFRI);
    }

    CurBB = FunctionBBs[0];
    continue;
  }

  case bitc::FUNC_CODE_DEBUG_LOC_AGAIN:  // DEBUG_LOC_AGAIN
    // This record indicates that the last instruction is at the same
    // location as the previous instruction with a location.
    I = getLastInstruction();

    if (!I)
      return error("Invalid record");
    I->setDebugLoc(LastLoc);
    I = nullptr;
    continue;

  case bitc::FUNC_CODE_DEBUG_LOC: {      // DEBUG_LOC: [line, col, scope, ia]
    I = getLastInstruction();
    if (!I || Record.size() < 4)
      return error("Invalid record");

    unsigned Line = Record[0], Col = Record[1];
    unsigned ScopeID = Record[2], IAID = Record[3];

    MDNode *Scope = nullptr, *IA = nullptr;
    if (ScopeID) {
      Scope = MDLoader->getMDNodeFwdRefOrNull(ScopeID - 1);
      if (!Scope)
        return error("Invalid record");
    }
    if (IAID) {
      IA = MDLoader->getMDNodeFwdRefOrNull(IAID - 1);
      if (!IA)
        return error("Invalid record");
    }
    LastLoc = DebugLoc::get(Line, Col, Scope, IA);
    I->setDebugLoc(LastLoc);
    I = nullptr;
    continue;
  }

  case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opval, ty, opval, opcode]
    unsigned OpNum = 0;
    Value *LHS, *RHS;
    if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
        popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
        OpNum+1 > Record.size())
      return error("Invalid record");

    int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
    if (Opc == -1)
      return error("Invalid record");
    I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
    InstructionList.push_back(I);
    if (OpNum < Record.size()) {
      if (Opc == Instruction::Add ||
          Opc == Instruction::Sub ||
          Opc == Instruction::Mul ||
          Opc == Instruction::Shl) {
        if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
          cast<BinaryOperator>(I)->setHasNoSignedWrap(true);
        if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
          cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);
      } else if (Opc == Instruction::SDiv ||
                 Opc == Instruction::UDiv ||
                 Opc == Instruction::LShr ||
                 Opc == Instruction::AShr) {
        if (Record[OpNum] & (1 << bitc::PEO_EXACT))
          cast<BinaryOperator>(I)->setIsExact(true);
      } else if (isa<FPMathOperator>(I)) {
        FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
        if (FMF.any())
          I->setFastMathFlags(FMF);
      }

    }
    break;
  }
  case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opval, opty, destty, castopc]
    unsigned OpNum = 0;
    Value *Op;
    if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
        OpNum+2 != Record.size())
      return error("Invalid record");

    Type *ResTy = getTypeByID(Record[OpNum]);
    int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
    if (Opc == -1 || !ResTy)
      return error("Invalid record");
    Instruction *Temp = nullptr;
    if ((I = UpgradeBitCastInst(Opc, Op, ResTy, Temp))) {
      if (Temp) {
        InstructionList.push_back(Temp);
        CurBB->getInstList().push_back(Temp);
      }
    } else {
      auto CastOp = (Instruction::CastOps)Opc;
      if (!CastInst::castIsValid(CastOp, Op, ResTy))
        return error("Invalid cast");
      I = CastInst::Create(CastOp, Op, ResTy);
    }
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD:
  case bitc::FUNC_CODE_INST_GEP_OLD:
  case bitc::FUNC_CODE_INST_GEP: { // GEP: type, [n x operands]
    unsigned OpNum = 0;

    Type *Ty;
    bool InBounds;

    if (BitCode == bitc::FUNC_CODE_INST_GEP) {
      InBounds = Record[OpNum++];
      Ty = getTypeByID(Record[OpNum++]);
    } else {
      InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
      Ty = nullptr;
    }

    Value *BasePtr;
    if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
      return error("Invalid record");

    if (!Ty)
      Ty = cast<PointerType>(BasePtr->getType()->getScalarType())
               ->getElementType();
    else if (Ty !=
             cast<PointerType>(BasePtr->getType()->getScalarType())
                 ->getElementType())
      return error(
          "Explicit gep type does not match pointee type of pointer operand");

    SmallVector<Value*, 16> GEPIdx;
    while (OpNum != Record.size()) {
      Value *Op;
      if (getValueTypePair(Record, OpNum, NextValueNo, Op))
        return error("Invalid record");
      GEPIdx.push_back(Op);
    }

    I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);

    InstructionList.push_back(I);
    if (InBounds)
      cast<GetElementPtrInst>(I)->setIsInBounds(true);
    break;
  }

  case bitc::FUNC_CODE_INST_EXTRACTVAL: {
                                     // EXTRACTVAL: [opty, opval, n x indices]
    unsigned OpNum = 0;
    Value *Agg;
    if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
      return error("Invalid record");

    unsigned RecSize = Record.size();
    if (OpNum == RecSize)
      return error("EXTRACTVAL: Invalid instruction with 0 indices");

    SmallVector<unsigned, 4> EXTRACTVALIdx;
    Type *CurTy = Agg->getType();
    for (; OpNum != RecSize; ++OpNum) {
      bool IsArray = CurTy->isArrayTy();
      bool IsStruct = CurTy->isStructTy();
      uint64_t Index = Record[OpNum];

      if (!IsStruct && !IsArray)
        return error("EXTRACTVAL: Invalid type");
      if ((unsigned)Index != Index)
        return error("Invalid value");
      if (IsStruct && Index >= CurTy->subtypes().size())
        return error("EXTRACTVAL: Invalid struct index");
      if (IsArray && Index >= CurTy->getArrayNumElements())
        return error("EXTRACTVAL: Invalid array index");
      EXTRACTVALIdx.push_back((unsigned)Index);

      if (IsStruct)
        CurTy = CurTy->subtypes()[Index];
      else
        CurTy = CurTy->subtypes()[0];
    }

    I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_INSERTVAL: {
                         // INSERTVAL: [opty, opval, opty, opval, n x indices]
    unsigned OpNum = 0;
    Value *Agg;
    if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
      return error("Invalid record");
    Value *Val;
    if (getValueTypePair(Record, OpNum, NextValueNo, Val))
      return error("Invalid record");

    unsigned RecSize = Record.size();
    if (OpNum == RecSize)
      return error("INSERTVAL: Invalid instruction with 0 indices");

    SmallVector<unsigned, 4> INSERTVALIdx;
    Type *CurTy = Agg->getType();
    for (; OpNum != RecSize; ++OpNum) {
      bool IsArray = CurTy->isArrayTy();
      bool IsStruct = CurTy->isStructTy();
      uint64_t Index = Record[OpNum];

      if (!IsStruct && !IsArray)
        return error("INSERTVAL: Invalid type");
      if ((unsigned)Index != Index)
        return error("Invalid value");
      if (IsStruct && Index >= CurTy->subtypes().size())
        return error("INSERTVAL: Invalid struct index");
      if (IsArray && Index >= CurTy->getArrayNumElements())
        return error("INSERTVAL: Invalid array index");

      INSERTVALIdx.push_back((unsigned)Index);
      if (IsStruct)
        CurTy = CurTy->subtypes()[Index];
      else
        CurTy = CurTy->subtypes()[0];
    }

    if (CurTy != Val->getType())
      return error("Inserted value type doesn't match aggregate type");

    I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval]
    // obsolete form of select
    // handles select i1 ... in old bitcode
    unsigned OpNum = 0;
    Value *TrueVal, *FalseVal, *Cond;
    if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
        popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
        popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
      return error("Invalid record");

    I = SelectInst::Create(Cond, TrueVal, FalseVal);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]
    // new form of select
    // handles select i1 or select [N x i1]
    unsigned OpNum = 0;
    Value *TrueVal, *FalseVal, *Cond;
    if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
        popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
        getValueTypePair(Record, OpNum, NextValueNo, Cond))
      return error("Invalid record");

    // select condition can be either i1 or [N x i1]
    if (VectorType* vector_type =
        dyn_cast<VectorType>(Cond->getType())) {
      // expect <n x i1>
      if (vector_type->getElementType() != Type::getInt1Ty(Context))
        return error("Invalid type for value");
    } else {
      // expect i1
      if (Cond->getType() != Type::getInt1Ty(Context))
        return error("Invalid type for value");
    }

    I = SelectInst::Create(Cond, TrueVal, FalseVal);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
    unsigned OpNum = 0;
    Value *Vec, *Idx;
    if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
        getValueTypePair(Record, OpNum, NextValueNo, Idx))
      return error("Invalid record");
    if (!Vec->getType()->isVectorTy())
      return error("Invalid type for value");
    I = ExtractElementInst::Create(Vec, Idx);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
    unsigned OpNum = 0;
    Value *Vec, *Elt, *Idx;
    if (getValueTypePair(Record, OpNum, NextValueNo, Vec))
      return error("Invalid record");
    if (!Vec->getType()->isVectorTy())
      return error("Invalid type for value");
    if (popValue(Record, OpNum, NextValueNo,
                 cast<VectorType>(Vec->getType())->getElementType(), Elt) ||
        getValueTypePair(Record, OpNum, NextValueNo, Idx))
      return error("Invalid record");
    I = InsertElementInst::Create(Vec, Elt, Idx);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
    unsigned OpNum = 0;
    Value *Vec1, *Vec2, *Mask;
    if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
        popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
      return error("Invalid record");

    if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
      return error("Invalid record");
    if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())
      return error("Invalid type for value");
    I = new ShuffleVectorInst(Vec1, Vec2, Mask);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_CMP:   // CMP: [opty, opval, opval, pred]
    // Old form of ICmp/FCmp returning bool
    // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
    // both legal on vectors but had different behaviour.
  case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred]
    // FCmp/ICmp returning bool or vector of bool

    unsigned OpNum = 0;
    Value *LHS, *RHS;
    if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
        popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
      return error("Invalid record");

    unsigned PredVal = Record[OpNum];
    bool IsFP = LHS->getType()->isFPOrFPVectorTy();
    FastMathFlags FMF;
    if (IsFP && Record.size() > OpNum+1)
      FMF = getDecodedFastMathFlags(Record[++OpNum]);

    if (OpNum+1 != Record.size())
      return error("Invalid record");

    if (LHS->getType()->isFPOrFPVectorTy())
      I = new FCmpInst((FCmpInst::Predicate)PredVal, LHS, RHS);
    else
      I = new ICmpInst((ICmpInst::Predicate)PredVal, LHS, RHS);

    if (FMF.any())
      I->setFastMathFlags(FMF);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
    {
      unsigned Size = Record.size();
      if (Size == 0) {
        I = ReturnInst::Create(Context);
        InstructionList.push_back(I);
        break;
      }

      unsigned OpNum = 0;
      Value *Op = nullptr;
      if (getValueTypePair(Record, OpNum, NextValueNo, Op))
        return error("Invalid record");
      if (OpNum != Record.size())
        return error("Invalid record");

      I = ReturnInst::Create(Context, Op);
      InstructionList.push_back(I);
      break;
    }
  case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#]
    if (Record.size() != 1 && Record.size() != 3)
      return error("Invalid record");
    BasicBlock *TrueDest = getBasicBlock(Record[0]);
    if (!TrueDest)
      return error("Invalid record");

    if (Record.size() == 1) {
      I = BranchInst::Create(TrueDest);
      InstructionList.push_back(I);
    }
    else {
      BasicBlock *FalseDest = getBasicBlock(Record[1]);
      Value *Cond = getValue(Record, 2, NextValueNo,
                             Type::getInt1Ty(Context));
      if (!FalseDest || !Cond)
        return error("Invalid record");
      I = BranchInst::Create(TrueDest, FalseDest, Cond);
      InstructionList.push_back(I);
    }
    break;
  }
  case bitc::FUNC_CODE_INST_CLEANUPRET: { // CLEANUPRET: [val] or [val,bb#]
    if (Record.size() != 1 && Record.size() != 2)
      return error("Invalid record");
    unsigned Idx = 0;
    Value *CleanupPad =
        getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
    if (!CleanupPad)
      return error("Invalid record");
    BasicBlock *UnwindDest = nullptr;
    if (Record.size() == 2) {
      UnwindDest = getBasicBlock(Record[Idx++]);
      if (!UnwindDest)
        return error("Invalid record");
    }

    I = CleanupReturnInst::Create(CleanupPad, UnwindDest);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [val,bb#]
    if (Record.size() != 2)
      return error("Invalid record");
    unsigned Idx = 0;
    Value *CatchPad =
        getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
    if (!CatchPad)
      return error("Invalid record");
    BasicBlock *BB = getBasicBlock(Record[Idx++]);
    if (!BB)
      return error("Invalid record");

    I = CatchReturnInst::Create(CatchPad, BB);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?]
    // We must have, at minimum, the outer scope and the number of arguments.
    if (Record.size() < 2)
      return error("Invalid record");

    unsigned Idx = 0;

    Value *ParentPad =
        getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));

    unsigned NumHandlers = Record[Idx++];

    SmallVector<BasicBlock *, 2> Handlers;
    for (unsigned Op = 0; Op != NumHandlers; ++Op) {
      BasicBlock *BB = getBasicBlock(Record[Idx++]);
      if (!BB)
        return error("Invalid record");
      Handlers.push_back(BB);
    }

    BasicBlock *UnwindDest = nullptr;
    if (Idx + 1 == Record.size()) {
      UnwindDest = getBasicBlock(Record[Idx++]);
      if (!UnwindDest)
        return error("Invalid record");
    }

    if (Record.size() != Idx)
      return error("Invalid record");

    auto *CatchSwitch =
        CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);
    for (BasicBlock *Handler : Handlers)
      CatchSwitch->addHandler(Handler);
    I = CatchSwitch;
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_CATCHPAD:
  case bitc::FUNC_CODE_INST_CLEANUPPAD: { // [tok,num,(ty,val)*]
    // We must have, at minimum, the outer scope and the number of arguments.
    if (Record.size() < 2)
      return error("Invalid record");

    unsigned Idx = 0;

    Value *ParentPad =
        getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));

    unsigned NumArgOperands = Record[Idx++];

    SmallVector<Value *, 2> Args;
    for (unsigned Op = 0; Op != NumArgOperands; ++Op) {
      Value *Val;
      if (getValueTypePair(Record, Idx, NextValueNo, Val))
        return error("Invalid record");
      Args.push_back(Val);
    }

    if (Record.size() != Idx)
      return error("Invalid record");

    if (BitCode == bitc::FUNC_CODE_INST_CLEANUPPAD)
      I = CleanupPadInst::Create(ParentPad, Args);
    else
      I = CatchPadInst::Create(ParentPad, Args);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
    // Check magic
    if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
      // "New" SwitchInst format with case ranges. The changes to write this
      // format were reverted but we still recognize bitcode that uses it.
      // Hopefully someday we will have support for case ranges and can use
      // this format again.

      Type *OpTy = getTypeByID(Record[1]);
      unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();

      Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
      BasicBlock *Default = getBasicBlock(Record[3]);
      if (!OpTy || !Cond || !Default)
        return error("Invalid record");

      unsigned NumCases = Record[4];

      SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
      InstructionList.push_back(SI);

      unsigned CurIdx = 5;
      for (unsigned i = 0; i != NumCases; ++i) {
        SmallVector<ConstantInt*, 1> CaseVals;
        unsigned NumItems = Record[CurIdx++];
        for (unsigned ci = 0; ci != NumItems; ++ci) {
          bool isSingleNumber = Record[CurIdx++];

          APInt Low;
          unsigned ActiveWords = 1;
          if (ValueBitWidth > 64)
            ActiveWords = Record[CurIdx++];
          Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
                              ValueBitWidth);
          CurIdx += ActiveWords;

          if (!isSingleNumber) {
            ActiveWords = 1;
            if (ValueBitWidth > 64)
              ActiveWords = Record[CurIdx++];
            APInt High = readWideAPInt(
                makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
            CurIdx += ActiveWords;

            // FIXME: It is not clear whether values in the range should be
            // compared as signed or unsigned values. The partially
            // implemented changes that used this format in the past used
            // unsigned comparisons.
            for ( ; Low.ule(High); ++Low)
              CaseVals.push_back(ConstantInt::get(Context, Low));
          } else
            CaseVals.push_back(ConstantInt::get(Context, Low));
        }
        BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
        for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
               cve = CaseVals.end(); cvi != cve; ++cvi)
          SI->addCase(*cvi, DestBB);
      }
      I = SI;
      break;
    }

    // Old SwitchInst format without case ranges.

    if (Record.size() < 3 || (Record.size() & 1) == 0)
      return error("Invalid record");
    Type *OpTy = getTypeByID(Record[0]);
    Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
    BasicBlock *Default = getBasicBlock(Record[2]);
    if (!OpTy || !Cond || !Default)
      return error("Invalid record");
    unsigned NumCases = (Record.size()-3)/2;
    SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
    InstructionList.push_back(SI);
    for (unsigned i = 0, e = NumCases; i != e; ++i) {
      ConstantInt *CaseVal =
        dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
      BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
      if (!CaseVal || !DestBB) {
        delete SI;
        return error("Invalid record");
      }
      SI->addCase(CaseVal, DestBB);
    }
    I = SI;
    break;
  }
  case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
    if (Record.size() < 2)
      return error("Invalid record");
    Type *OpTy = getTypeByID(Record[0]);
    Value *Address = getValue(Record, 1, NextValueNo, OpTy);
    if (!OpTy || !Address)
      return error("Invalid record");
    unsigned NumDests = Record.size()-2;
    IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
    InstructionList.push_back(IBI);
    for (unsigned i = 0, e = NumDests; i != e; ++i) {
      if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
        IBI->addDestination(DestBB);
      } else {
        delete IBI;
        return error("Invalid record");
      }
    }
    I = IBI;
    break;
  }

  case bitc::FUNC_CODE_INST_INVOKE: {
    // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]
    if (Record.size() < 4)
      return error("Invalid record");
    unsigned OpNum = 0;
    AttributeList PAL = getAttributes(Record[OpNum++]);
    unsigned CCInfo = Record[OpNum++];
    BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
    BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);

    FunctionType *FTy = nullptr;
    if (CCInfo >> 13 & 1 &&
        !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
      return error("Explicit invoke type is not a function type");

    Value *Callee;
    if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
      return error("Invalid record");

    PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
    if (!CalleeTy)
      return error("Callee is not a pointer");
    if (!FTy) {
      FTy = dyn_cast<FunctionType>(CalleeTy->getElementType());
      if (!FTy)
        return error("Callee is not of pointer to function type");
    } else if (CalleeTy->getElementType() != FTy)
      return error("Explicit invoke type does not match pointee type of "
                   "callee operand");
    if (Record.size() < FTy->getNumParams() + OpNum)
      return error("Insufficient operands to call");

    SmallVector<Value*, 16> Ops;
    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
      Ops.push_back(getValue(Record, OpNum, NextValueNo,
                             FTy->getParamType(i)));
      if (!Ops.back())
        return error("Invalid record");
    }

    if (!FTy->isVarArg()) {
      if (Record.size() != OpNum)
        return error("Invalid record");
    } else {
      // Read type/value pairs for varargs params.
      while (OpNum != Record.size()) {
        Value *Op;
        if (getValueTypePair(Record, OpNum, NextValueNo, Op))
          return error("Invalid record");
        Ops.push_back(Op);
      }
    }

    I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops, OperandBundles);
    OperandBundles.clear();
    InstructionList.push_back(I);
    cast<InvokeInst>(I)->setCallingConv(
        static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo));
    cast<InvokeInst>(I)->setAttributes(PAL);
    break;
  }
  case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
    unsigned Idx = 0;
    Value *Val = nullptr;
    if (getValueTypePair(Record, Idx, NextValueNo, Val))
      return error("Invalid record");
    I = ResumeInst::Create(Val);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
    I = new UnreachableInst(Context);
    InstructionList.push_back(I);
    break;
  case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
    if (Record.size() < 1 || ((Record.size()-1)&1))
      return error("Invalid record");
    Type *Ty = getTypeByID(Record[0]);
    if (!Ty)
      return error("Invalid record");

    PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2);
    InstructionList.push_back(PN);

    for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) {
      Value *V;
      // With the new function encoding, it is possible that operands have
      // negative IDs (for forward references).  Use a signed VBR
      // representation to keep the encoding small.
      if (UseRelativeIDs)
        V = getValueSigned(Record, 1+i, NextValueNo, Ty);
      else
        V = getValue(Record, 1+i, NextValueNo, Ty);
      BasicBlock *BB = getBasicBlock(Record[2+i]);
      if (!V || !BB)
        return error("Invalid record");
      PN->addIncoming(V, BB);
    }
    I = PN;
    break;
  }

  case bitc::FUNC_CODE_INST_LANDINGPAD:
  case bitc::FUNC_CODE_INST_LANDINGPAD_OLD: {
    // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
    unsigned Idx = 0;
    if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) {
      if (Record.size() < 3)
        return error("Invalid record");
    } else {
      assert(BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD)(static_cast <bool> (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD
) ? void (0) : __assert_fail ("BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4182, __extension__ __PRETTY_FUNCTION__));
      if (Record.size() < 4)
        return error("Invalid record");
    }
    Type *Ty = getTypeByID(Record[Idx++]);
    if (!Ty)
      return error("Invalid record");
    if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
      Value *PersFn = nullptr;
      if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
        return error("Invalid record");

      if (!F->hasPersonalityFn())
        F->setPersonalityFn(cast<Constant>(PersFn));
      else if (F->getPersonalityFn() != cast<Constant>(PersFn))
        return error("Personality function mismatch");
    }

    bool IsCleanup = !!Record[Idx++];
    unsigned NumClauses = Record[Idx++];
    LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
    LP->setCleanup(IsCleanup);
    for (unsigned J = 0; J != NumClauses; ++J) {
      LandingPadInst::ClauseType CT =
        LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
      Value *Val;

      if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
        delete LP;
        return error("Invalid record");
      }

      assert((CT != LandingPadInst::Catch ||(static_cast <bool> ((CT != LandingPadInst::Catch || !isa
<ArrayType>(Val->getType())) && "Catch clause has a invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Catch || !isa<ArrayType>(Val->getType())) && \"Catch clause has a invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4216, __extension__ __PRETTY_FUNCTION__))
              !isa<ArrayType>(Val->getType())) &&(static_cast <bool> ((CT != LandingPadInst::Catch || !isa
<ArrayType>(Val->getType())) && "Catch clause has a invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Catch || !isa<ArrayType>(Val->getType())) && \"Catch clause has a invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4216, __extension__ __PRETTY_FUNCTION__))
             "Catch clause has a invalid type!")(static_cast <bool> ((CT != LandingPadInst::Catch || !isa
<ArrayType>(Val->getType())) && "Catch clause has a invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Catch || !isa<ArrayType>(Val->getType())) && \"Catch clause has a invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4216, __extension__ __PRETTY_FUNCTION__));
      assert((CT != LandingPadInst::Filter ||(static_cast <bool> ((CT != LandingPadInst::Filter || isa
<ArrayType>(Val->getType())) && "Filter clause has invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Filter || isa<ArrayType>(Val->getType())) && \"Filter clause has invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4219, __extension__ __PRETTY_FUNCTION__))
              isa<ArrayType>(Val->getType())) &&(static_cast <bool> ((CT != LandingPadInst::Filter || isa
<ArrayType>(Val->getType())) && "Filter clause has invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Filter || isa<ArrayType>(Val->getType())) && \"Filter clause has invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4219, __extension__ __PRETTY_FUNCTION__))
             "Filter clause has invalid type!")(static_cast <bool> ((CT != LandingPadInst::Filter || isa
<ArrayType>(Val->getType())) && "Filter clause has invalid type!"
) ? void (0) : __assert_fail ("(CT != LandingPadInst::Filter || isa<ArrayType>(Val->getType())) && \"Filter clause has invalid type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4219, __extension__ __PRETTY_FUNCTION__));
      LP->addClause(cast<Constant>(Val));
    }

    I = LP;
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align]
    if (Record.size() != 4)
      return error("Invalid record");
    uint64_t AlignRecord = Record[3];
    const uint64_t InAllocaMask = uint64_t(1) << 5;
    const uint64_t ExplicitTypeMask = uint64_t(1) << 6;
    const uint64_t SwiftErrorMask = uint64_t(1) << 7;
    const uint64_t FlagMask = InAllocaMask | ExplicitTypeMask |
                              SwiftErrorMask;
    bool InAlloca = AlignRecord & InAllocaMask;
    bool SwiftError = AlignRecord & SwiftErrorMask;
    Type *Ty = getTypeByID(Record[0]);
    if ((AlignRecord & ExplicitTypeMask) == 0) {
      auto *PTy = dyn_cast_or_null<PointerType>(Ty);
      if (!PTy)
        return error("Old-style alloca with a non-pointer type");
      Ty = PTy->getElementType();
    }
    Type *OpTy = getTypeByID(Record[1]);
    Value *Size = getFnValueByID(Record[2], OpTy);
    unsigned Align;
    if (Error Err = parseAlignmentValue(AlignRecord & ~FlagMask, Align)) {
      return Err;
    }
    if (!Ty || !Size)
      return error("Invalid record");

    // FIXME: Make this an optional field.
    const DataLayout &DL = TheModule->getDataLayout();
    unsigned AS = DL.getAllocaAddrSpace();

    AllocaInst *AI = new AllocaInst(Ty, AS, Size, Align);
    AI->setUsedWithInAlloca(InAlloca);
    AI->setSwiftError(SwiftError);
    I = AI;
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
    unsigned OpNum = 0;
    Value *Op;
    if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
        (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
      return error("Invalid record");

    Type *Ty = nullptr;
    if (OpNum + 3 == Record.size())
      Ty = getTypeByID(Record[OpNum++]);
    if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
      return Err;
    if (!Ty)
      Ty = cast<PointerType>(Op->getType())->getElementType();

    unsigned Align;
    if (Error Err = parseAlignmentValue(Record[OpNum], Align))
      return Err;
    I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);

    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_LOADATOMIC: {
     // LOADATOMIC: [opty, op, align, vol, ordering, ssid]
    unsigned OpNum = 0;
    Value *Op;
    if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
        (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
      return error("Invalid record");

    Type *Ty = nullptr;
    if (OpNum + 5 == Record.size())
      Ty = getTypeByID(Record[OpNum++]);
    if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
      return Err;
    if (!Ty)
      Ty = cast<PointerType>(Op->getType())->getElementType();

    AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
    if (Ordering == AtomicOrdering::NotAtomic ||
        Ordering == AtomicOrdering::Release ||
        Ordering == AtomicOrdering::AcquireRelease)
      return error("Invalid record");
    if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
      return error("Invalid record");
    SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);

    unsigned Align;
    if (Error Err = parseAlignmentValue(Record[OpNum], Align))
      return Err;
    I = new LoadInst(Op, "", Record[OpNum+1], Align, Ordering, SSID);

    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_STORE:
  case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
    unsigned OpNum = 0;
    Value *Val, *Ptr;
    if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
        (BitCode == bitc::FUNC_CODE_INST_STORE
             ? getValueTypePair(Record, OpNum, NextValueNo, Val)
             : popValue(Record, OpNum, NextValueNo,
                        cast<PointerType>(Ptr->getType())->getElementType(),
                        Val)) ||
        OpNum + 2 != Record.size())
      return error("Invalid record");

    if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
      return Err;
    unsigned Align;
    if (Error Err = parseAlignmentValue(Record[OpNum], Align))
      return Err;
    I = new StoreInst(Val, Ptr, Record[OpNum+1], Align);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_STOREATOMIC:
  case bitc::FUNC_CODE_INST_STOREATOMIC_OLD: {
    // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]
    unsigned OpNum = 0;
    Value *Val, *Ptr;
    if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
        !isa<PointerType>(Ptr->getType()) ||
        (BitCode == bitc::FUNC_CODE_INST_STOREATOMIC
             ? getValueTypePair(Record, OpNum, NextValueNo, Val)
             : popValue(Record, OpNum, NextValueNo,
                        cast<PointerType>(Ptr->getType())->getElementType(),
                        Val)) ||
        OpNum + 4 != Record.size())
      return error("Invalid record");

    if (Error Err = typeCheckLoadStoreInst(Val->getType(), Ptr->getType()))
      return Err;
    AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
    if (Ordering == AtomicOrdering::NotAtomic ||
        Ordering == AtomicOrdering::Acquire ||
        Ordering == AtomicOrdering::AcquireRelease)
      return error("Invalid record");
    SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
    if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
      return error("Invalid record");

    unsigned Align;
    if (Error Err = parseAlignmentValue(Record[OpNum], Align))
      return Err;
    I = new StoreInst(Val, Ptr, Record[OpNum+1], Align, Ordering, SSID);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_CMPXCHG_OLD:
  case bitc::FUNC_CODE_INST_CMPXCHG: {
    // CMPXCHG:[ptrty, ptr, cmp, new, vol, successordering, ssid,
    //          failureordering?, isweak?]
    unsigned OpNum = 0;
    Value *Ptr, *Cmp, *New;
    if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
        (BitCode == bitc::FUNC_CODE_INST_CMPXCHG
             ? getValueTypePair(Record, OpNum, NextValueNo, Cmp)
             : popValue(Record, OpNum, NextValueNo,
                        cast<PointerType>(Ptr->getType())->getElementType(),
                        Cmp)) ||
        popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
        Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
      return error("Invalid record");
    AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]);
    if (SuccessOrdering == AtomicOrdering::NotAtomic ||
        SuccessOrdering == AtomicOrdering::Unordered)
      return error("Invalid record");
    SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);

    if (Error Err = typeCheckLoadStoreInst(Cmp->getType(), Ptr->getType()))
      return Err;
    AtomicOrdering FailureOrdering;
    if (Record.size() < 7)
      FailureOrdering =
          AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering);
    else
      FailureOrdering = getDecodedOrdering(Record[OpNum + 3]);

    I = new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering, FailureOrdering,
                              SSID);
    cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);

    if (Record.size() < 8) {
      // Before weak cmpxchgs existed, the instruction simply returned the
      // value loaded from memory, so bitcode files from that era will be
      // expecting the first component of a modern cmpxchg.
      CurBB->getInstList().push_back(I);
      I = ExtractValueInst::Create(I, 0);
    } else {
      cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
    }

    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_ATOMICRMW: {
    // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, ssid]
    unsigned OpNum = 0;
    Value *Ptr, *Val;
    if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
        !isa<PointerType>(Ptr->getType()) ||
        popValue(Record, OpNum, NextValueNo,
                  cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
        OpNum+4 != Record.size())
      return error("Invalid record");
    AtomicRMWInst::BinOp Operation = getDecodedRMWOperation(Record[OpNum]);
    if (Operation < AtomicRMWInst::FIRST_BINOP ||
        Operation > AtomicRMWInst::LAST_BINOP)
      return error("Invalid record");
    AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
    if (Ordering == AtomicOrdering::NotAtomic ||
        Ordering == AtomicOrdering::Unordered)
      return error("Invalid record");
    SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
    I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SSID);
    cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, ssid]
    if (2 != Record.size())
      return error("Invalid record");
    AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
    if (Ordering == AtomicOrdering::NotAtomic ||
        Ordering == AtomicOrdering::Unordered ||
        Ordering == AtomicOrdering::Monotonic)
      return error("Invalid record");
    SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);
    I = new FenceInst(Context, Ordering, SSID);
    InstructionList.push_back(I);
    break;
  }
  case bitc::FUNC_CODE_INST_CALL: {
    // CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]
    if (Record.size() < 3)
      return error("Invalid record");

    unsigned OpNum = 0;
    AttributeList PAL = getAttributes(Record[OpNum++]);
    unsigned CCInfo = Record[OpNum++];

    FastMathFlags FMF;
    if ((CCInfo >> bitc::CALL_FMF) & 1) {
      FMF = getDecodedFastMathFlags(Record[OpNum++]);
      if (!FMF.any())
        return error("Fast math flags indicator set for call with no FMF");
    }

    FunctionType *FTy = nullptr;
    if (CCInfo >> bitc::CALL_EXPLICIT_TYPE & 1 &&
        !(FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]))))
      return error("Explicit call type is not a function type");

    Value *Callee;
    if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
      return error("Invalid record");

    PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
    if (!OpTy)
      return error("Callee is not a pointer type");
    if (!FTy) {
      FTy = dyn_cast<FunctionType>(OpTy->getElementType());
      if (!FTy)
        return error("Callee is not of pointer to function type");
    } else if (OpTy->getElementType() != FTy)
      return error("Explicit call type does not match pointee type of "
                   "callee operand");
    if (Record.size() < FTy->getNumParams() + OpNum)
      return error("Insufficient operands to call");

    SmallVector<Value*, 16> Args;
    // Read the fixed params.
    for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
      if (FTy->getParamType(i)->isLabelTy())
        Args.push_back(getBasicBlock(Record[OpNum]));
      else
        Args.push_back(getValue(Record, OpNum, NextValueNo,
                                FTy->getParamType(i)));
      if (!Args.back())
        return error("Invalid record");
    }

    // Read type/value pairs for varargs params.
    if (!FTy->isVarArg()) {
      if (OpNum != Record.size())
        return error("Invalid record");
    } else {
      while (OpNum != Record.size()) {
        Value *Op;
        if (getValueTypePair(Record, OpNum, NextValueNo, Op))
          return error("Invalid record");
        Args.push_back(Op);
      }
    }

    I = CallInst::Create(FTy, Callee, Args, OperandBundles);
    OperandBundles.clear();
    InstructionList.push_back(I);
    cast<CallInst>(I)->setCallingConv(
        static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
    CallInst::TailCallKind TCK = CallInst::TCK_None;
    if (CCInfo & 1 << bitc::CALL_TAIL)
      TCK = CallInst::TCK_Tail;
    if (CCInfo & (1 << bitc::CALL_MUSTTAIL))
      TCK = CallInst::TCK_MustTail;
    if (CCInfo & (1 << bitc::CALL_NOTAIL))
      TCK = CallInst::TCK_NoTail;
    cast<CallInst>(I)->setTailCallKind(TCK);
    cast<CallInst>(I)->setAttributes(PAL);
    if (FMF.any()) {
      if (!isa<FPMathOperator>(I))
        return error("Fast-math-flags specified for call without "
                     "floating-point scalar or vector return type");
      I->setFastMathFlags(FMF);
    }
    break;
  }
  case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
    if (Record.size() < 3)
      return error("Invalid record");
    Type *OpTy = getTypeByID(Record[0]);
    Value *Op = getValue(Record, 1, NextValueNo, OpTy);
    Type *ResTy = getTypeByID(Record[2]);
    if (!OpTy || !Op || !ResTy)
      return error("Invalid record");
    I = new VAArgInst(Op, ResTy);
    InstructionList.push_back(I);
    break;
  }

  case bitc::FUNC_CODE_OPERAND_BUNDLE: {
    // A call or an invoke can be optionally prefixed with some variable
    // number of operand bundle blocks.  These blocks are read into
    // OperandBundles and consumed at the next call or invoke instruction.

    if (Record.size() < 1 || Record[0] >= BundleTags.size())
      return error("Invalid record");

    std::vector<Value *> Inputs;

    unsigned OpNum = 1;
    while (OpNum != Record.size()) {
      Value *Op;
      if (getValueTypePair(Record, OpNum, NextValueNo, Op))
        return error("Invalid record");
      Inputs.push_back(Op);
    }

    OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
    continue;
  }
  }

  // Add instruction to end of current BB.  If there is no current BB, reject
  // this file.
  if (!CurBB) {
    I->deleteValue();
    return error("Invalid instruction with no BB");
  }
  if (!OperandBundles.empty()) {
    I->deleteValue();
    return error("Operand bundles found with no consumer");
  }
  CurBB->getInstList().push_back(I);

  // If this was a terminator instruction, move to the next block.
  if (isa<TerminatorInst>(I)) {
    ++CurBBNo;
    CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
  }

  // Non-void values get registered in the value table for future use.
  if (I && !I->getType()->isVoidTy())
    ValueList.assignValue(I, NextValueNo++);
}

4605OutOfRecordLoop:

if (!OperandBundles.empty())
  return error("Operand bundles found with no consumer");

// Check the function list for unresolved values.
if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
  if (!A->getParent()) {
    // We found at least one unresolved value.  Nuke them all to avoid leaks.
    for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
      if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {
        A->replaceAllUsesWith(UndefValue::get(A->getType()));
        delete A;
      }
    }
    return error("Never resolved value found in function");
  }
}

// Unexpected unresolved metadata about to be dropped.
if (MDLoader->hasFwdRefs())
  return error("Invalid function metadata: outgoing forward refs");

// Trim the value list down to the size it was before we parsed this function.
ValueList.shrinkTo(ModuleValueListSize);
MDLoader->shrinkTo(ModuleMDLoaderSize);
std::vector<BasicBlock*>().swap(FunctionBBs);
return Error::success();
4633}

4635/// Find the function body in the bitcode stream
4636Error BitcodeReader::findFunctionInStream(
  Function *F,
  DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
while (DeferredFunctionInfoIterator->second == 0) {
  // This is the fallback handling for the old format bitcode that
  // didn't contain the function index in the VST, or when we have
  // an anonymous function which would not have a VST entry.
  // Assert that we have one of those two cases.
  assert(VSTOffset == 0 || !F->hasName())(static_cast <bool> (VSTOffset == 0 || !F->hasName()
) ? void (0) : __assert_fail ("VSTOffset == 0 || !F->hasName()"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4644, __extension__ __PRETTY_FUNCTION__));
  // Parse the next body in the stream and set its position in the
  // DeferredFunctionInfo map.
  if (Error Err = rememberAndSkipFunctionBodies())
    return Err;
}
return Error::success();
4651}

4653SyncScope::ID BitcodeReader::getDecodedSyncScopeID(unsigned Val) {
if (Val == SyncScope::SingleThread || Val == SyncScope::System)
  return SyncScope::ID(Val);
if (Val >= SSIDs.size())
  return SyncScope::System; // Map unknown synchronization scopes to system.
return SSIDs[Val];
4659}

4661//===----------------------------------------------------------------------===//
4662// GVMaterializer implementation
4663//===----------------------------------------------------------------------===//

4665Error BitcodeReader::materialize(GlobalValue *GV) {
Function *F = dyn_cast<Function>(GV);
// If it's not a function or is already material, ignore the request.
if (!F || !F->isMaterializable())
  return Error::success();

DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!")(static_cast <bool> (DFII != DeferredFunctionInfo.end()
 && "Deferred function not found!") ? void (0) : __assert_fail
 ("DFII != DeferredFunctionInfo.end() && \"Deferred function not found!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4672, __extension__ __PRETTY_FUNCTION__));
// If its position is recorded as 0, its body is somewhere in the stream
// but we haven't seen it yet.
if (DFII->second == 0)
  if (Error Err = findFunctionInStream(F, DFII))
    return Err;

// Materialize metadata before parsing any function bodies.
if (Error Err = materializeMetadata())
  return Err;

// Move the bit stream to the saved position of the deferred function body.
Stream.JumpToBit(DFII->second);

if (Error Err = parseFunctionBody(F))
  return Err;
F->setIsMaterializable(false);

if (StripDebugInfo)
  stripDebugInfo(*F);

// Upgrade any old intrinsic calls in the function.
for (auto &I : UpgradedIntrinsics) {
  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
       UI != UE;) {
    User *U = *UI;
    ++UI;
    if (CallInst *CI = dyn_cast<CallInst>(U))
      UpgradeIntrinsicCall(CI, I.second);
  }
}

// Update calls to the remangled intrinsics
for (auto &I : RemangledIntrinsics)
  for (auto UI = I.first->materialized_user_begin(), UE = I.first->user_end();
       UI != UE;)
    // Don't expect any other users than call sites
    CallSite(*UI++).setCalledFunction(I.second);

// Finish fn->subprogram upgrade for materialized functions.
if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(F))
  F->setSubprogram(SP);

// Check if the TBAA Metadata are valid, otherwise we will need to strip them.
if (!MDLoader->isStrippingTBAA()) {
  for (auto &I : instructions(F)) {
    MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa);
    if (!TBAA || TBAAVerifyHelper.visitTBAAMetadata(I, TBAA))
      continue;
    MDLoader->setStripTBAA(true);
    stripTBAA(F->getParent());
  }
}

// Bring in any functions that this function forward-referenced via
// blockaddresses.
return materializeForwardReferencedFunctions();
4729}

4731Error BitcodeReader::materializeModule() {
if (Error Err = materializeMetadata())
  return Err;

// Promise to materialize all forward references.
WillMaterializeAllForwardRefs = true;

// Iterate over the module, deserializing any functions that are still on
// disk.
for (Function &F : *TheModule) {
  if (Error Err = materialize(&F))
    return Err;
}
// At this point, if there are any function bodies, parse the rest of
// the bits in the module past the last function block we have recorded
// through either lazy scanning or the VST.
if (LastFunctionBlockBit || NextUnreadBit)
  if (Error Err = parseModule(LastFunctionBlockBit > NextUnreadBit
                                  ? LastFunctionBlockBit
                                  : NextUnreadBit))
    return Err;

// Check that all block address forward references got resolved (as we
// promised above).
if (!BasicBlockFwdRefs.empty())
  return error("Never resolved function from blockaddress");

// Upgrade any intrinsic calls that slipped through (should not happen!) and
// delete the old functions to clean up. We can't do this unless the entire
// module is materialized because there could always be another function body
// with calls to the old function.
for (auto &I : UpgradedIntrinsics) {
  for (auto *U : I.first->users()) {
    if (CallInst *CI = dyn_cast<CallInst>(U))
      UpgradeIntrinsicCall(CI, I.second);
  }
  if (!I.first->use_empty())
    I.first->replaceAllUsesWith(I.second);
  I.first->eraseFromParent();
}
UpgradedIntrinsics.clear();
// Do the same for remangled intrinsics
for (auto &I : RemangledIntrinsics) {
  I.first->replaceAllUsesWith(I.second);
  I.first->eraseFromParent();
}
RemangledIntrinsics.clear();

UpgradeDebugInfo(*TheModule);

UpgradeModuleFlags(*TheModule);
return Error::success();
4783}

4785std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const {
return IdentifiedStructTypes;
4787}

4789ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(
  BitstreamCursor Cursor, StringRef Strtab, ModuleSummaryIndex &TheIndex,
  StringRef ModulePath, unsigned ModuleId)
  : BitcodeReaderBase(std::move(Cursor), Strtab), TheIndex(TheIndex),
    ModulePath(ModulePath), ModuleId(ModuleId) {}

4795ModuleSummaryIndex::ModuleInfo *
4796ModuleSummaryIndexBitcodeReader::addThisModule() {
return TheIndex.addModule(ModulePath, ModuleId);
4798}

4800std::pair<ValueInfo, GlobalValue::GUID>
4801ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(unsigned ValueId) {
auto VGI = ValueIdToValueInfoMap[ValueId];
assert(VGI.first)(static_cast <bool> (VGI.first) ? void (0) : __assert_fail
 ("VGI.first", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4803, __extension__ __PRETTY_FUNCTION__));
return VGI;
4805}

4807void ModuleSummaryIndexBitcodeReader::setValueGUID(
  uint64_t ValueID, StringRef ValueName, GlobalValue::LinkageTypes Linkage,
  StringRef SourceFileName) {
std::string GlobalId =
    GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);
auto ValueGUID = GlobalValue::getGUID(GlobalId);
auto OriginalNameID = ValueGUID;
if (GlobalValue::isLocalLinkage(Linkage))
  OriginalNameID = GlobalValue::getGUID(ValueName);
if (PrintSummaryGUIDs)
  dbgs() << "GUID " << ValueGUID << "(" << OriginalNameID << ") is "
         << ValueName << "\n";

// UseStrtab is false for legacy summary formats and value names are
// created on stack. We can't use them outside of parseValueSymbolTable.
ValueIdToValueInfoMap[ValueID] = std::make_pair(
    TheIndex.getOrInsertValueInfo(ValueGUID, UseStrtab ? ValueName : ""),
    OriginalNameID);
4825}

4827// Specialized value symbol table parser used when reading module index
4828// blocks where we don't actually create global values. The parsed information
4829// is saved in the bitcode reader for use when later parsing summaries.
4830Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(
  uint64_t Offset,
  DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {
// With a strtab the VST is not required to parse the summary.
if (UseStrtab)
  return Error::success();

assert(Offset > 0 && "Expected non-zero VST offset")(static_cast <bool> (Offset > 0 && "Expected non-zero VST offset"
) ? void (0) : __assert_fail ("Offset > 0 && \"Expected non-zero VST offset\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4837, __extension__ __PRETTY_FUNCTION__));
uint64_t CurrentBit = jumpToValueSymbolTable(Offset, Stream);

if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

// Read all the records for this value table.
SmallString<128> ValueName;

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:
    // Done parsing VST, jump back to wherever we came from.
    Stream.JumpToBit(CurrentBit);
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record.
  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
    break;
  case bitc::VST_CODE_ENTRY: { // VST_CODE_ENTRY: [valueid, namechar x N]
    if (convertToString(Record, 1, ValueName))
      return error("Invalid record");
    unsigned ValueID = Record[0];
    assert(!SourceFileName.empty())(static_cast <bool> (!SourceFileName.empty()) ? void (0
) : __assert_fail ("!SourceFileName.empty()", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4873, __extension__ __PRETTY_FUNCTION__));
    auto VLI = ValueIdToLinkageMap.find(ValueID);
    assert(VLI != ValueIdToLinkageMap.end() &&(static_cast <bool> (VLI != ValueIdToLinkageMap.end() &&
 "No linkage found for VST entry?") ? void (0) : __assert_fail
 ("VLI != ValueIdToLinkageMap.end() && \"No linkage found for VST entry?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4876, __extension__ __PRETTY_FUNCTION__))
           "No linkage found for VST entry?")(static_cast <bool> (VLI != ValueIdToLinkageMap.end() &&
 "No linkage found for VST entry?") ? void (0) : __assert_fail
 ("VLI != ValueIdToLinkageMap.end() && \"No linkage found for VST entry?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4876, __extension__ __PRETTY_FUNCTION__));
    auto Linkage = VLI->second;
    setValueGUID(ValueID, ValueName, Linkage, SourceFileName);
    ValueName.clear();
    break;
  }
  case bitc::VST_CODE_FNENTRY: {
    // VST_CODE_FNENTRY: [valueid, offset, namechar x N]
    if (convertToString(Record, 2, ValueName))
      return error("Invalid record");
    unsigned ValueID = Record[0];
    assert(!SourceFileName.empty())(static_cast <bool> (!SourceFileName.empty()) ? void (0
) : __assert_fail ("!SourceFileName.empty()", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4887, __extension__ __PRETTY_FUNCTION__));
    auto VLI = ValueIdToLinkageMap.find(ValueID);
    assert(VLI != ValueIdToLinkageMap.end() &&(static_cast <bool> (VLI != ValueIdToLinkageMap.end() &&
 "No linkage found for VST entry?") ? void (0) : __assert_fail
 ("VLI != ValueIdToLinkageMap.end() && \"No linkage found for VST entry?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4890, __extension__ __PRETTY_FUNCTION__))
           "No linkage found for VST entry?")(static_cast <bool> (VLI != ValueIdToLinkageMap.end() &&
 "No linkage found for VST entry?") ? void (0) : __assert_fail
 ("VLI != ValueIdToLinkageMap.end() && \"No linkage found for VST entry?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4890, __extension__ __PRETTY_FUNCTION__));
    auto Linkage = VLI->second;
    setValueGUID(ValueID, ValueName, Linkage, SourceFileName);
    ValueName.clear();
    break;
  }
  case bitc::VST_CODE_COMBINED_ENTRY: {
    // VST_CODE_COMBINED_ENTRY: [valueid, refguid]
    unsigned ValueID = Record[0];
    GlobalValue::GUID RefGUID = Record[1];
    // The "original name", which is the second value of the pair will be
    // overriden later by a FS_COMBINED_ORIGINAL_NAME in the combined index.
    ValueIdToValueInfoMap[ValueID] =
        std::make_pair(TheIndex.getOrInsertValueInfo(RefGUID), RefGUID);
    break;
  }
  }
}
4908}

4910// Parse just the blocks needed for building the index out of the module.
4911// At the end of this routine the module Index is populated with a map
4912// from global value id to GlobalValueSummary objects.
4913Error ModuleSummaryIndexBitcodeReader::parseModule() {
if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;
DenseMap<unsigned, GlobalValue::LinkageTypes> ValueIdToLinkageMap;
unsigned ValueId = 0;

// Read the index for this module.
while (true) {
  BitstreamEntry Entry = Stream.advance();

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return Error::success();

  case BitstreamEntry::SubBlock:
    switch (Entry.ID) {
    default: // Skip unknown content.
      if (Stream.SkipBlock())
        return error("Invalid record");
      break;
    case bitc::BLOCKINFO_BLOCK_ID:
      // Need to parse these to get abbrev ids (e.g. for VST)
      if (readBlockInfo())
        return error("Malformed block");
      break;
    case bitc::VALUE_SYMTAB_BLOCK_ID:
      // Should have been parsed earlier via VSTOffset, unless there
      // is no summary section.
      assert(((SeenValueSymbolTable && VSTOffset > 0) ||(static_cast <bool> (((SeenValueSymbolTable && VSTOffset
 > 0) || !SeenGlobalValSummary) && "Expected early VST parse via VSTOffset record"
) ? void (0) : __assert_fail ("((SeenValueSymbolTable && VSTOffset > 0) || !SeenGlobalValSummary) && \"Expected early VST parse via VSTOffset record\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4947, __extension__ __PRETTY_FUNCTION__))
              !SeenGlobalValSummary) &&(static_cast <bool> (((SeenValueSymbolTable && VSTOffset
 > 0) || !SeenGlobalValSummary) && "Expected early VST parse via VSTOffset record"
) ? void (0) : __assert_fail ("((SeenValueSymbolTable && VSTOffset > 0) || !SeenGlobalValSummary) && \"Expected early VST parse via VSTOffset record\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4947, __extension__ __PRETTY_FUNCTION__))
             "Expected early VST parse via VSTOffset record")(static_cast <bool> (((SeenValueSymbolTable && VSTOffset
 > 0) || !SeenGlobalValSummary) && "Expected early VST parse via VSTOffset record"
) ? void (0) : __assert_fail ("((SeenValueSymbolTable && VSTOffset > 0) || !SeenGlobalValSummary) && \"Expected early VST parse via VSTOffset record\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4947, __extension__ __PRETTY_FUNCTION__));
      if (Stream.SkipBlock())
        return error("Invalid record");
      break;
    case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
    case bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:
      assert(!SeenValueSymbolTable &&(static_cast <bool> (!SeenValueSymbolTable && "Already read VST when parsing summary block?"
) ? void (0) : __assert_fail ("!SeenValueSymbolTable && \"Already read VST when parsing summary block?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4954, __extension__ __PRETTY_FUNCTION__))
             "Already read VST when parsing summary block?")(static_cast <bool> (!SeenValueSymbolTable && "Already read VST when parsing summary block?"
) ? void (0) : __assert_fail ("!SeenValueSymbolTable && \"Already read VST when parsing summary block?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 4954, __extension__ __PRETTY_FUNCTION__));
      // We might not have a VST if there were no values in the
      // summary. An empty summary block generated when we are
      // performing ThinLTO compiles so we don't later invoke
      // the regular LTO process on them.
      if (VSTOffset > 0) {
        if (Error Err = parseValueSymbolTable(VSTOffset, ValueIdToLinkageMap))
          return Err;
        SeenValueSymbolTable = true;
      }
      SeenGlobalValSummary = true;
      if (Error Err = parseEntireSummary(Entry.ID))
        return Err;
      break;
    case bitc::MODULE_STRTAB_BLOCK_ID:
      if (Error Err = parseModuleStringTable())
        return Err;
      break;
    }
    continue;

  case BitstreamEntry::Record: {
      Record.clear();
      auto BitCode = Stream.readRecord(Entry.ID, Record);
      switch (BitCode) {
      default:
        break; // Default behavior, ignore unknown content.
      case bitc::MODULE_CODE_VERSION: {
        if (Error Err = parseVersionRecord(Record).takeError())
          return Err;
        break;
      }
      /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]
      case bitc::MODULE_CODE_SOURCE_FILENAME: {
        SmallString<128> ValueName;
        if (convertToString(Record, 0, ValueName))
          return error("Invalid record");
        SourceFileName = ValueName.c_str();
        break;
      }
      /// MODULE_CODE_HASH: [5*i32]
      case bitc::MODULE_CODE_HASH: {
        if (Record.size() != 5)
          return error("Invalid hash length " + Twine(Record.size()).str());
        auto &Hash = addThisModule()->second.second;
        int Pos = 0;
        for (auto &Val : Record) {
          assert(!(Val >> 32) && "Unexpected high bits set")(static_cast <bool> (!(Val >> 32) && "Unexpected high bits set"
) ? void (0) : __assert_fail ("!(Val >> 32) && \"Unexpected high bits set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5001, __extension__ __PRETTY_FUNCTION__));
          Hash[Pos++] = Val;
        }
        break;
      }
      /// MODULE_CODE_VSTOFFSET: [offset]
      case bitc::MODULE_CODE_VSTOFFSET:
        if (Record.size() < 1)
          return error("Invalid record");
        // Note that we subtract 1 here because the offset is relative to one
        // word before the start of the identification or module block, which
        // was historically always the start of the regular bitcode header.
        VSTOffset = Record[0] - 1;
        break;
      // v1 GLOBALVAR: [pointer type, isconst,     initid,       linkage, ...]
      // v1 FUNCTION:  [type,         callingconv, isproto,      linkage, ...]
      // v1 ALIAS:     [alias type,   addrspace,   aliasee val#, linkage, ...]
      // v2: [strtab offset, strtab size, v1]
      case bitc::MODULE_CODE_GLOBALVAR:
      case bitc::MODULE_CODE_FUNCTION:
      case bitc::MODULE_CODE_ALIAS: {
        StringRef Name;
        ArrayRef<uint64_t> GVRecord;
        std::tie(Name, GVRecord) = readNameFromStrtab(Record);
        if (GVRecord.size() <= 3)
          return error("Invalid record");
        uint64_t RawLinkage = GVRecord[3];
        GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
        if (!UseStrtab) {
          ValueIdToLinkageMap[ValueId++] = Linkage;
          break;
        }

        setValueGUID(ValueId++, Name, Linkage, SourceFileName);
        break;
      }
      }
    }
    continue;
  }
}
5042}

5044std::vector<ValueInfo>
5045ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) {
std::vector<ValueInfo> Ret;
Ret.reserve(Record.size());
for (uint64_t RefValueId : Record)
  Ret.push_back(getValueInfoFromValueId(RefValueId).first);
return Ret;
5051}

5053std::vector<FunctionSummary::EdgeTy>
5054ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record,
                                            bool IsOldProfileFormat,
                                            bool HasProfile, bool HasRelBF) {
std::vector<FunctionSummary::EdgeTy> Ret;
Ret.reserve(Record.size());
for (unsigned I = 0, E = Record.size(); I != E; ++I) {
  CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;
  uint64_t RelBF = 0;
  ValueInfo Callee = getValueInfoFromValueId(Record[I]).first;
  if (IsOldProfileFormat) {
    I += 1; // Skip old callsitecount field
    if (HasProfile)
      I += 1; // Skip old profilecount field
  } else if (HasProfile)
    Hotness = static_cast<CalleeInfo::HotnessType>(Record[++I]);
  else if (HasRelBF)
    RelBF = Record[++I];
  Ret.push_back(FunctionSummary::EdgeTy{Callee, CalleeInfo(Hotness, RelBF)});
}
return Ret;
5074}

5076static void
5077parseWholeProgramDevirtResolutionByArg(ArrayRef<uint64_t> Record, size_t &Slot,
                                     WholeProgramDevirtResolution &Wpd) {
uint64_t ArgNum = Record[Slot++];
WholeProgramDevirtResolution::ByArg &B =
    Wpd.ResByArg[{Record.begin() + Slot, Record.begin() + Slot + ArgNum}];
Slot += ArgNum;

B.TheKind =
    static_cast<WholeProgramDevirtResolution::ByArg::Kind>(Record[Slot++]);
B.Info = Record[Slot++];
B.Byte = Record[Slot++];
B.Bit = Record[Slot++];
5089}

5091static void parseWholeProgramDevirtResolution(ArrayRef<uint64_t> Record,
                                            StringRef Strtab, size_t &Slot,
                                            TypeIdSummary &TypeId) {
uint64_t Id = Record[Slot++];
WholeProgramDevirtResolution &Wpd = TypeId.WPDRes[Id];

Wpd.TheKind = static_cast<WholeProgramDevirtResolution::Kind>(Record[Slot++]);
Wpd.SingleImplName = {Strtab.data() + Record[Slot],
                      static_cast<size_t>(Record[Slot + 1])};
Slot += 2;

uint64_t ResByArgNum = Record[Slot++];
for (uint64_t I = 0; I != ResByArgNum; ++I)
  parseWholeProgramDevirtResolutionByArg(Record, Slot, Wpd);
5105}

5107static void parseTypeIdSummaryRecord(ArrayRef<uint64_t> Record,
                                   StringRef Strtab,
                                   ModuleSummaryIndex &TheIndex) {
size_t Slot = 0;
TypeIdSummary &TypeId = TheIndex.getOrInsertTypeIdSummary(
    {Strtab.data() + Record[Slot], static_cast<size_t>(Record[Slot + 1])});
Slot += 2;

TypeId.TTRes.TheKind = static_cast<TypeTestResolution::Kind>(Record[Slot++]);
TypeId.TTRes.SizeM1BitWidth = Record[Slot++];
TypeId.TTRes.AlignLog2 = Record[Slot++];
TypeId.TTRes.SizeM1 = Record[Slot++];
TypeId.TTRes.BitMask = Record[Slot++];
TypeId.TTRes.InlineBits = Record[Slot++];

while (Slot < Record.size())
  parseWholeProgramDevirtResolution(Record, Strtab, Slot, TypeId);
5124}

5126// Eagerly parse the entire summary block. This populates the GlobalValueSummary
5127// objects in the index.
5128Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(unsigned ID) {
if (Stream.EnterSubBlock(ID))
  return error("Invalid record");
SmallVector<uint64_t, 64> Record;

// Parse version
{
  BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
  if (Entry.Kind != BitstreamEntry::Record)
    return error("Invalid Summary Block: record for version expected");
  if (Stream.readRecord(Entry.ID, Record) != bitc::FS_VERSION)
    return error("Invalid Summary Block: version expected");
}
const uint64_t Version = Record[0];
const bool IsOldProfileFormat = Version == 1;
if (Version < 1 || Version > 4)
  return error("Invalid summary version " + Twine(Version) +
               ", 1, 2, 3 or 4 expected");
Record.clear();

// Keep around the last seen summary to be used when we see an optional
// "OriginalName" attachement.
GlobalValueSummary *LastSeenSummary = nullptr;
GlobalValue::GUID LastSeenGUID = 0;

// We can expect to see any number of type ID information records before
// each function summary records; these variables store the information
// collected so far so that it can be used to create the summary object.
std::vector<GlobalValue::GUID> PendingTypeTests;
std::vector<FunctionSummary::VFuncId> PendingTypeTestAssumeVCalls,
    PendingTypeCheckedLoadVCalls;
std::vector<FunctionSummary::ConstVCall> PendingTypeTestAssumeConstVCalls,
    PendingTypeCheckedLoadConstVCalls;

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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  // Read a record. The record format depends on whether this
  // is a per-module index or a combined index file. In the per-module
  // case the records contain the associated value's ID for correlation
  // with VST entries. In the combined index the correlation is done
  // via the bitcode offset of the summary records (which were saved
  // in the combined index VST entries). The records also contain
  // information used for ThinLTO renaming and importing.
  Record.clear();
  auto BitCode = Stream.readRecord(Entry.ID, Record);
  switch (BitCode) {
  default: // Default behavior: ignore.
    break;
  case bitc::FS_FLAGS: {  // [flags]
    uint64_t Flags = Record[0];
    // Scan flags (set only on the combined index).
    assert(Flags <= 0x3 && "Unexpected bits in flag")(static_cast <bool> (Flags <= 0x3 && "Unexpected bits in flag"
) ? void (0) : __assert_fail ("Flags <= 0x3 && \"Unexpected bits in flag\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5191, __extension__ __PRETTY_FUNCTION__));

    // 1 bit: WithGlobalValueDeadStripping flag.
    if (Flags & 0x1)
      TheIndex.setWithGlobalValueDeadStripping();
    // 1 bit: SkipModuleByDistributedBackend flag.
    if (Flags & 0x2)
      TheIndex.setSkipModuleByDistributedBackend();
    break;
  }
  case bitc::FS_VALUE_GUID: { // [valueid, refguid]
    uint64_t ValueID = Record[0];
    GlobalValue::GUID RefGUID = Record[1];
    ValueIdToValueInfoMap[ValueID] =
        std::make_pair(TheIndex.getOrInsertValueInfo(RefGUID), RefGUID);
    break;
  }
  // FS_PERMODULE: [valueid, flags, instcount, fflags, numrefs,
  //                numrefs x valueid, n x (valueid)]
  // FS_PERMODULE_PROFILE: [valueid, flags, instcount, fflags, numrefs,
  //                        numrefs x valueid,
  //                        n x (valueid, hotness)]
  // FS_PERMODULE_RELBF: [valueid, flags, instcount, fflags, numrefs,
  //                      numrefs x valueid,
  //                      n x (valueid, relblockfreq)]
  case bitc::FS_PERMODULE:
  case bitc::FS_PERMODULE_RELBF:
  case bitc::FS_PERMODULE_PROFILE: {
    unsigned ValueID = Record[0];
    uint64_t RawFlags = Record[1];
    unsigned InstCount = Record[2];
    uint64_t RawFunFlags = 0;
    unsigned NumRefs = Record[3];
    int RefListStartIndex = 4;
    if (Version >= 4) {
      RawFunFlags = Record[3];
      NumRefs = Record[4];
      RefListStartIndex = 5;
    }

    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    // The module path string ref set in the summary must be owned by the
    // index's module string table. Since we don't have a module path
    // string table section in the per-module index, we create a single
    // module path string table entry with an empty (0) ID to take
    // ownership.
    int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
    assert(Record.size() >= RefListStartIndex + NumRefs &&(static_cast <bool> (Record.size() >= RefListStartIndex
 + NumRefs && "Record size inconsistent with number of references"
) ? void (0) : __assert_fail ("Record.size() >= RefListStartIndex + NumRefs && \"Record size inconsistent with number of references\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5239, __extension__ __PRETTY_FUNCTION__))
           "Record size inconsistent with number of references")(static_cast <bool> (Record.size() >= RefListStartIndex
 + NumRefs && "Record size inconsistent with number of references"
) ? void (0) : __assert_fail ("Record.size() >= RefListStartIndex + NumRefs && \"Record size inconsistent with number of references\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5239, __extension__ __PRETTY_FUNCTION__));
    std::vector<ValueInfo> Refs = makeRefList(
        ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
    bool HasProfile = (BitCode == bitc::FS_PERMODULE_PROFILE);
    bool HasRelBF = (BitCode == bitc::FS_PERMODULE_RELBF);
    std::vector<FunctionSummary::EdgeTy> Calls = makeCallList(
        ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
        IsOldProfileFormat, HasProfile, HasRelBF);
    auto FS = llvm::make_unique<FunctionSummary>(
        Flags, InstCount, getDecodedFFlags(RawFunFlags), std::move(Refs),
        std::move(Calls), std::move(PendingTypeTests),
        std::move(PendingTypeTestAssumeVCalls),
        std::move(PendingTypeCheckedLoadVCalls),
        std::move(PendingTypeTestAssumeConstVCalls),
        std::move(PendingTypeCheckedLoadConstVCalls));
    PendingTypeTests.clear();
    PendingTypeTestAssumeVCalls.clear();
    PendingTypeCheckedLoadVCalls.clear();
    PendingTypeTestAssumeConstVCalls.clear();
    PendingTypeCheckedLoadConstVCalls.clear();
    auto VIAndOriginalGUID = getValueInfoFromValueId(ValueID);
    FS->setModulePath(addThisModule()->first());
    FS->setOriginalName(VIAndOriginalGUID.second);
    TheIndex.addGlobalValueSummary(VIAndOriginalGUID.first, std::move(FS));
    break;
  }
  // FS_ALIAS: [valueid, flags, valueid]
  // Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as
  // they expect all aliasee summaries to be available.
  case bitc::FS_ALIAS: {
    unsigned ValueID = Record[0];
    uint64_t RawFlags = Record[1];
    unsigned AliaseeID = Record[2];
    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    auto AS = llvm::make_unique<AliasSummary>(Flags);
    // The module path string ref set in the summary must be owned by the
    // index's module string table. Since we don't have a module path
    // string table section in the per-module index, we create a single
    // module path string table entry with an empty (0) ID to take
    // ownership.
    AS->setModulePath(addThisModule()->first());

    GlobalValue::GUID AliaseeGUID =
        getValueInfoFromValueId(AliaseeID).first.getGUID();
    auto AliaseeInModule =
        TheIndex.findSummaryInModule(AliaseeGUID, ModulePath);
    if (!AliaseeInModule)
      return error("Alias expects aliasee summary to be parsed");
    AS->setAliasee(AliaseeInModule);
    AS->setAliaseeGUID(AliaseeGUID);

    auto GUID = getValueInfoFromValueId(ValueID);
    AS->setOriginalName(GUID.second);
    TheIndex.addGlobalValueSummary(GUID.first, std::move(AS));
    break;
  }
  // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
  case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
    unsigned ValueID = Record[0];
    uint64_t RawFlags = Record[1];
    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    std::vector<ValueInfo> Refs =
        makeRefList(ArrayRef<uint64_t>(Record).slice(2));
    auto FS = llvm::make_unique<GlobalVarSummary>(Flags, std::move(Refs));
    FS->setModulePath(addThisModule()->first());
    auto GUID = getValueInfoFromValueId(ValueID);
    FS->setOriginalName(GUID.second);
    TheIndex.addGlobalValueSummary(GUID.first, std::move(FS));
    break;
  }
  // FS_COMBINED: [valueid, modid, flags, instcount, fflags, numrefs,
  //               numrefs x valueid, n x (valueid)]
  // FS_COMBINED_PROFILE: [valueid, modid, flags, instcount, fflags, numrefs,
  //                       numrefs x valueid, n x (valueid, hotness)]
  case bitc::FS_COMBINED:
  case bitc::FS_COMBINED_PROFILE: {
    unsigned ValueID = Record[0];
    uint64_t ModuleId = Record[1];
    uint64_t RawFlags = Record[2];
    unsigned InstCount = Record[3];
    uint64_t RawFunFlags = 0;
    unsigned NumRefs = Record[4];
    int RefListStartIndex = 5;

    if (Version >= 4) {
      RawFunFlags = Record[4];
      NumRefs = Record[5];
      RefListStartIndex = 6;
    }

    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
    assert(Record.size() >= RefListStartIndex + NumRefs &&(static_cast <bool> (Record.size() >= RefListStartIndex
 + NumRefs && "Record size inconsistent with number of references"
) ? void (0) : __assert_fail ("Record.size() >= RefListStartIndex + NumRefs && \"Record size inconsistent with number of references\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5332, __extension__ __PRETTY_FUNCTION__))
           "Record size inconsistent with number of references")(static_cast <bool> (Record.size() >= RefListStartIndex
 + NumRefs && "Record size inconsistent with number of references"
) ? void (0) : __assert_fail ("Record.size() >= RefListStartIndex + NumRefs && \"Record size inconsistent with number of references\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5332, __extension__ __PRETTY_FUNCTION__));
    std::vector<ValueInfo> Refs = makeRefList(
        ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
    bool HasProfile = (BitCode == bitc::FS_COMBINED_PROFILE);
    std::vector<FunctionSummary::EdgeTy> Edges = makeCallList(
        ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
        IsOldProfileFormat, HasProfile, false);
    ValueInfo VI = getValueInfoFromValueId(ValueID).first;
    auto FS = llvm::make_unique<FunctionSummary>(
        Flags, InstCount, getDecodedFFlags(RawFunFlags), std::move(Refs),
        std::move(Edges), std::move(PendingTypeTests),
        std::move(PendingTypeTestAssumeVCalls),
        std::move(PendingTypeCheckedLoadVCalls),
        std::move(PendingTypeTestAssumeConstVCalls),
        std::move(PendingTypeCheckedLoadConstVCalls));
    PendingTypeTests.clear();
    PendingTypeTestAssumeVCalls.clear();
    PendingTypeCheckedLoadVCalls.clear();
    PendingTypeTestAssumeConstVCalls.clear();
    PendingTypeCheckedLoadConstVCalls.clear();
    LastSeenSummary = FS.get();
    LastSeenGUID = VI.getGUID();
    FS->setModulePath(ModuleIdMap[ModuleId]);
    TheIndex.addGlobalValueSummary(VI, std::move(FS));
    break;
  }
  // FS_COMBINED_ALIAS: [valueid, modid, flags, valueid]
  // Aliases must be emitted (and parsed) after all FS_COMBINED entries, as
  // they expect all aliasee summaries to be available.
  case bitc::FS_COMBINED_ALIAS: {
    unsigned ValueID = Record[0];
    uint64_t ModuleId = Record[1];
    uint64_t RawFlags = Record[2];
    unsigned AliaseeValueId = Record[3];
    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    auto AS = llvm::make_unique<AliasSummary>(Flags);
    LastSeenSummary = AS.get();
    AS->setModulePath(ModuleIdMap[ModuleId]);

    auto AliaseeGUID =
        getValueInfoFromValueId(AliaseeValueId).first.getGUID();
    auto AliaseeInModule =
        TheIndex.findSummaryInModule(AliaseeGUID, AS->modulePath());
    AS->setAliasee(AliaseeInModule);
    AS->setAliaseeGUID(AliaseeGUID);

    ValueInfo VI = getValueInfoFromValueId(ValueID).first;
    LastSeenGUID = VI.getGUID();
    TheIndex.addGlobalValueSummary(VI, std::move(AS));
    break;
  }
  // FS_COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
  case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {
    unsigned ValueID = Record[0];
    uint64_t ModuleId = Record[1];
    uint64_t RawFlags = Record[2];
    auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
    std::vector<ValueInfo> Refs =
        makeRefList(ArrayRef<uint64_t>(Record).slice(3));
    auto FS = llvm::make_unique<GlobalVarSummary>(Flags, std::move(Refs));
    LastSeenSummary = FS.get();
    FS->setModulePath(ModuleIdMap[ModuleId]);
    ValueInfo VI = getValueInfoFromValueId(ValueID).first;
    LastSeenGUID = VI.getGUID();
    TheIndex.addGlobalValueSummary(VI, std::move(FS));
    break;
  }
  // FS_COMBINED_ORIGINAL_NAME: [original_name]
  case bitc::FS_COMBINED_ORIGINAL_NAME: {
    uint64_t OriginalName = Record[0];
    if (!LastSeenSummary)
      return error("Name attachment that does not follow a combined record");
    LastSeenSummary->setOriginalName(OriginalName);
    TheIndex.addOriginalName(LastSeenGUID, OriginalName);
    // Reset the LastSeenSummary
    LastSeenSummary = nullptr;
    LastSeenGUID = 0;
    break;
  }
  case bitc::FS_TYPE_TESTS:
    assert(PendingTypeTests.empty())(static_cast <bool> (PendingTypeTests.empty()) ? void (
0) : __assert_fail ("PendingTypeTests.empty()", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5412, __extension__ __PRETTY_FUNCTION__));
    PendingTypeTests.insert(PendingTypeTests.end(), Record.begin(),
                            Record.end());
    break;

  case bitc::FS_TYPE_TEST_ASSUME_VCALLS:
    assert(PendingTypeTestAssumeVCalls.empty())(static_cast <bool> (PendingTypeTestAssumeVCalls.empty(
)) ? void (0) : __assert_fail ("PendingTypeTestAssumeVCalls.empty()"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5418, __extension__ __PRETTY_FUNCTION__));
    for (unsigned I = 0; I != Record.size(); I += 2)
      PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});
    break;

  case bitc::FS_TYPE_CHECKED_LOAD_VCALLS:
    assert(PendingTypeCheckedLoadVCalls.empty())(static_cast <bool> (PendingTypeCheckedLoadVCalls.empty
()) ? void (0) : __assert_fail ("PendingTypeCheckedLoadVCalls.empty()"
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5424, __extension__ __PRETTY_FUNCTION__));
    for (unsigned I = 0; I != Record.size(); I += 2)
      PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});
    break;

  case bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL:
    PendingTypeTestAssumeConstVCalls.push_back(
        {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
    break;

  case bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL:
    PendingTypeCheckedLoadConstVCalls.push_back(
        {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
    break;

  case bitc::FS_CFI_FUNCTION_DEFS: {
    std::set<std::string> &CfiFunctionDefs = TheIndex.cfiFunctionDefs();
    for (unsigned I = 0; I != Record.size(); I += 2)
      CfiFunctionDefs.insert(
          {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});
    break;
  }

  case bitc::FS_CFI_FUNCTION_DECLS: {
    std::set<std::string> &CfiFunctionDecls = TheIndex.cfiFunctionDecls();
    for (unsigned I = 0; I != Record.size(); I += 2)
      CfiFunctionDecls.insert(
          {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});
    break;
  }

  case bitc::FS_TYPE_ID:
    parseTypeIdSummaryRecord(Record, Strtab, TheIndex);
    break;
  }
}
llvm_unreachable("Exit infinite loop")::llvm::llvm_unreachable_internal("Exit infinite loop", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5460);
5461}

5463// Parse the  module string table block into the Index.
5464// This populates the ModulePathStringTable map in the index.
5465Error ModuleSummaryIndexBitcodeReader::parseModuleStringTable() {
if (Stream.EnterSubBlock(bitc::MODULE_STRTAB_BLOCK_ID))
  return error("Invalid record");

SmallVector<uint64_t, 64> Record;

SmallString<128> ModulePath;
ModuleSummaryIndex::ModuleInfo *LastSeenModule = nullptr;

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:
    return Error::success();
  case BitstreamEntry::Record:
    // The interesting case.
    break;
  }

  Record.clear();
  switch (Stream.readRecord(Entry.ID, Record)) {
  default: // Default behavior: ignore.
    break;
  case bitc::MST_CODE_ENTRY: {
    // MST_ENTRY: [modid, namechar x N]
    uint64_t ModuleId = Record[0];

    if (convertToString(Record, 1, ModulePath))
      return error("Invalid record");

    LastSeenModule = TheIndex.addModule(ModulePath, ModuleId);
    ModuleIdMap[ModuleId] = LastSeenModule->first();

    ModulePath.clear();
    break;
  }
  /// MST_CODE_HASH: [5*i32]
  case bitc::MST_CODE_HASH: {
    if (Record.size() != 5)
      return error("Invalid hash length " + Twine(Record.size()).str());
    if (!LastSeenModule)
      return error("Invalid hash that does not follow a module path");
    int Pos = 0;
    for (auto &Val : Record) {
      assert(!(Val >> 32) && "Unexpected high bits set")(static_cast <bool> (!(Val >> 32) && "Unexpected high bits set"
) ? void (0) : __assert_fail ("!(Val >> 32) && \"Unexpected high bits set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5513, __extension__ __PRETTY_FUNCTION__));
      LastSeenModule->second.second[Pos++] = Val;
    }
    // Reset LastSeenModule to avoid overriding the hash unexpectedly.
    LastSeenModule = nullptr;
    break;
  }
  }
}
llvm_unreachable("Exit infinite loop")::llvm::llvm_unreachable_internal("Exit infinite loop", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5522);
5523}

5525namespace {

5527// FIXME: This class is only here to support the transition to llvm::Error. It
5528// will be removed once this transition is complete. Clients should prefer to
5529// deal with the Error value directly, rather than converting to error_code.
5530class BitcodeErrorCategoryType : public std::error_category {
const char *name() const noexcept override {
  return "llvm.bitcode";
}

std::string message(int IE) const override {
  BitcodeError E = static_cast<BitcodeError>(IE);
  switch (E) {
  case BitcodeError::CorruptedBitcode:
    return "Corrupted bitcode";
  }
  llvm_unreachable("Unknown error type!")::llvm::llvm_unreachable_internal("Unknown error type!", "/build/llvm-toolchain-snapshot-7~svn326246/lib/Bitcode/Reader/BitcodeReader.cpp"
, 5541);
}
5543};

5545} // end anonymous namespace

5547static ManagedStatic<BitcodeErrorCategoryType> ErrorCategory;

5549const std::error_category &llvm::BitcodeErrorCategory() {
return *ErrorCategory;
33
←
Calling 'ManagedStatic::operator*'→
48
←
Returning from 'ManagedStatic::operator*'→
5551}

5553static Expected<StringRef> readBlobInRecord(BitstreamCursor &Stream,
                                          unsigned Block, unsigned RecordID) {
if (Stream.EnterSubBlock(Block))
  return error("Invalid record");

StringRef Strtab;
while (true) {
  BitstreamEntry Entry = Stream.advance();
  switch (Entry.Kind) {
  case BitstreamEntry::EndBlock:
    return Strtab;

  case BitstreamEntry::Error:
    return error("Malformed block");

  case BitstreamEntry::SubBlock:
    if (Stream.SkipBlock())
      return error("Malformed block");
    break;

  case BitstreamEntry::Record:
    StringRef Blob;
    SmallVector<uint64_t, 1> Record;
    if (Stream.readRecord(Entry.ID, Record, &Blob) == RecordID)
      Strtab = Blob;
    break;
  }
}
5581}

5583//===----------------------------------------------------------------------===//
5584// External interface
5585//===----------------------------------------------------------------------===//

5587Expected<std::vector<BitcodeModule>>
5588llvm::getBitcodeModuleList(MemoryBufferRef Buffer) {
auto FOrErr = getBitcodeFileContents(Buffer);
if (!FOrErr)
  return FOrErr.takeError();
return std::move(FOrErr->Mods);
5593}

5595Expected<BitcodeFileContents>
5596llvm::getBitcodeFileContents(MemoryBufferRef Buffer) {
Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
if (!StreamOrErr)
  return StreamOrErr.takeError();
BitstreamCursor &Stream = *StreamOrErr;

BitcodeFileContents F;
while (true) {
  uint64_t BCBegin = Stream.getCurrentByteNo();

  // We may be consuming bitcode from a client that leaves garbage at the end
  // of the bitcode stream (e.g. Apple's ar tool). If we are close enough to
  // the end that there cannot possibly be another module, stop looking.
  if (BCBegin + 8 >= Stream.getBitcodeBytes().size())
    return F;

  BitstreamEntry Entry = Stream.advance();
  switch (Entry.Kind) {
  case BitstreamEntry::EndBlock:
  case BitstreamEntry::Error:
    return error("Malformed block");

  case BitstreamEntry::SubBlock: {
    uint64_t IdentificationBit = -1ull;
    if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) {
      IdentificationBit = Stream.GetCurrentBitNo() - BCBegin * 8;
      if (Stream.SkipBlock())
        return error("Malformed block");

      Entry = Stream.advance();
      if (Entry.Kind != BitstreamEntry::SubBlock ||
          Entry.ID != bitc::MODULE_BLOCK_ID)
        return error("Malformed block");
    }

    if (Entry.ID == bitc::MODULE_BLOCK_ID) {
      uint64_t ModuleBit = Stream.GetCurrentBitNo() - BCBegin * 8;
      if (Stream.SkipBlock())
        return error("Malformed block");

      F.Mods.push_back({Stream.getBitcodeBytes().slice(
                            BCBegin, Stream.getCurrentByteNo() - BCBegin),
                        Buffer.getBufferIdentifier(), IdentificationBit,
                        ModuleBit});
      continue;
    }

    if (Entry.ID == bitc::STRTAB_BLOCK_ID) {
      Expected<StringRef> Strtab =
          readBlobInRecord(Stream, bitc::STRTAB_BLOCK_ID, bitc::STRTAB_BLOB);
      if (!Strtab)
        return Strtab.takeError();
      // This string table is used by every preceding bitcode module that does
      // not have its own string table. A bitcode file may have multiple
      // string tables if it was created by binary concatenation, for example
      // with "llvm-cat -b".
      for (auto I = F.Mods.rbegin(), E = F.Mods.rend(); I != E; ++I) {
        if (!I->Strtab.empty())
          break;
        I->Strtab = *Strtab;
      }
      // Similarly, the string table is used by every preceding symbol table;
      // normally there will be just one unless the bitcode file was created
      // by binary concatenation.
      if (!F.Symtab.empty() && F.StrtabForSymtab.empty())
        F.StrtabForSymtab = *Strtab;
      continue;
    }

    if (Entry.ID == bitc::SYMTAB_BLOCK_ID) {
      Expected<StringRef> SymtabOrErr =
          readBlobInRecord(Stream, bitc::SYMTAB_BLOCK_ID, bitc::SYMTAB_BLOB);
      if (!SymtabOrErr)
        return SymtabOrErr.takeError();

      // We can expect the bitcode file to have multiple symbol tables if it
      // was created by binary concatenation. In that case we silently
      // ignore any subsequent symbol tables, which is fine because this is a
      // low level function. The client is expected to notice that the number
      // of modules in the symbol table does not match the number of modules
      // in the input file and regenerate the symbol table.
      if (F.Symtab.empty())
        F.Symtab = *SymtabOrErr;
      continue;
    }

    if (Stream.SkipBlock())
      return error("Malformed block");
    continue;
  }
  case BitstreamEntry::Record:
    Stream.skipRecord(Entry.ID);
    continue;
  }
}
5691}

5693/// \brief Get a lazy one-at-time loading module from bitcode.
5694///
5695/// This isn't always used in a lazy context.  In particular, it's also used by
5696/// \a parseModule().  If this is truly lazy, then we need to eagerly pull
5697/// in forward-referenced functions from block address references.
5698///
5699/// \param[in] MaterializeAll Set to \c true if we should materialize
5700/// everything.
5701Expected<std::unique_ptr<Module>>
5702BitcodeModule::getModuleImpl(LLVMContext &Context, bool MaterializeAll,
                           bool ShouldLazyLoadMetadata, bool IsImporting) {
BitstreamCursor Stream(Buffer);

std::string ProducerIdentification;
if (IdentificationBit != -1ull) {
  Stream.JumpToBit(IdentificationBit);
  Expected<std::string> ProducerIdentificationOrErr =
      readIdentificationBlock(Stream);
  if (!ProducerIdentificationOrErr)
    return ProducerIdentificationOrErr.takeError();

  ProducerIdentification = *ProducerIdentificationOrErr;
}

Stream.JumpToBit(ModuleBit);
auto *R = new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
                            Context);

std::unique_ptr<Module> M =
    llvm::make_unique<Module>(ModuleIdentifier, Context);
M->setMaterializer(R);

// Delay parsing Metadata if ShouldLazyLoadMetadata is true.
if (Error Err =
        R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata, IsImporting))
  return std::move(Err);

if (MaterializeAll) {
  // Read in the entire module, and destroy the BitcodeReader.
  if (Error Err = M->materializeAll())
    return std::move(Err);
} else {
  // Resolve forward references from blockaddresses.
  if (Error Err = R->materializeForwardReferencedFunctions())
    return std::move(Err);
}
return std::move(M);
5740}

5742Expected<std::unique_ptr<Module>>
5743BitcodeModule::getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata,
                           bool IsImporting) {
return getModuleImpl(Context, false, ShouldLazyLoadMetadata, IsImporting);
5746}

5748// Parse the specified bitcode buffer and merge the index into CombinedIndex.
5749// We don't use ModuleIdentifier here because the client may need to control the
5750// module path used in the combined summary (e.g. when reading summaries for
5751// regular LTO modules).
5752Error BitcodeModule::readSummary(ModuleSummaryIndex &CombinedIndex,
                               StringRef ModulePath, uint64_t ModuleId) {
BitstreamCursor Stream(Buffer);
Stream.JumpToBit(ModuleBit);

ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, CombinedIndex,
                                  ModulePath, ModuleId);
return R.parseModule();
5760}

5762// Parse the specified bitcode buffer, returning the function info index.
5763Expected<std::unique_ptr<ModuleSummaryIndex>> BitcodeModule::getSummary() {
BitstreamCursor Stream(Buffer);
Stream.JumpToBit(ModuleBit);

auto Index =
    llvm::make_unique<ModuleSummaryIndex>(/*IsPerformingAnalysis=*/false);
ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,
                                  ModuleIdentifier, 0);

if (Error Err = R.parseModule())
  return std::move(Err);

return std::move(Index);
5776}

5778// Check if the given bitcode buffer contains a global value summary block.
5779Expected<BitcodeLTOInfo> BitcodeModule::getLTOInfo() {
BitstreamCursor Stream(Buffer);
Stream.JumpToBit(ModuleBit);

if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
  return error("Invalid record");

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

  switch (Entry.Kind) {
  case BitstreamEntry::Error:
    return error("Malformed block");
  case BitstreamEntry::EndBlock:
    return BitcodeLTOInfo{/*IsThinLTO=*/false, /*HasSummary=*/false};

  case BitstreamEntry::SubBlock:
    if (Entry.ID == bitc::GLOBALVAL_SUMMARY_BLOCK_ID)
      return BitcodeLTOInfo{/*IsThinLTO=*/true, /*HasSummary=*/true};

    if (Entry.ID == bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID)
      return BitcodeLTOInfo{/*IsThinLTO=*/false, /*HasSummary=*/true};

    // Ignore other sub-blocks.
    if (Stream.SkipBlock())
      return error("Malformed block");
    continue;

  case BitstreamEntry::Record:
    Stream.skipRecord(Entry.ID);
    continue;
  }
}
5812}

5814static Expected<BitcodeModule> getSingleModule(MemoryBufferRef Buffer) {
Expected<std::vector<BitcodeModule>> MsOrErr = getBitcodeModuleList(Buffer);
if (!MsOrErr)
  return MsOrErr.takeError();

if (MsOrErr->size() != 1)
  return error("Expected a single module");

return (*MsOrErr)[0];
5823}

5825Expected<std::unique_ptr<Module>>
5826llvm::getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context,
                         bool ShouldLazyLoadMetadata, bool IsImporting) {
Expected<BitcodeModule> BM = getSingleModule(Buffer);
if (!BM)
  return BM.takeError();

return BM->getLazyModule(Context, ShouldLazyLoadMetadata, IsImporting);
5833}

5835Expected<std::unique_ptr<Module>> llvm::getOwningLazyBitcodeModule(
  std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
  bool ShouldLazyLoadMetadata, bool IsImporting) {
auto MOrErr = getLazyBitcodeModule(*Buffer, Context, ShouldLazyLoadMetadata,
                                   IsImporting);
if (MOrErr)
  (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));
return MOrErr;
5843}

5845Expected<std::unique_ptr<Module>>
5846BitcodeModule::parseModule(LLVMContext &Context) {
return getModuleImpl(Context, true, false, false);
// TODO: Restore the use-lists to the in-memory state when the bitcode was
// written.  We must defer until the Module has been fully materialized.
5850}

5852Expected<std::unique_ptr<Module>> llvm::parseBitcodeFile(MemoryBufferRef Buffer,
                                                       LLVMContext &Context) {
Expected<BitcodeModule> BM = getSingleModule(Buffer);
if (!BM)
  return BM.takeError();

return BM->parseModule(Context);
5859}

5861Expected<std::string> llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer) {
Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
if (!StreamOrErr)
  return StreamOrErr.takeError();

return readTriple(*StreamOrErr);
5867}

5869Expected<bool> llvm::isBitcodeContainingObjCCategory(MemoryBufferRef Buffer) {
Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
if (!StreamOrErr)
  return StreamOrErr.takeError();

return hasObjCCategory(*StreamOrErr);
5875}

5877Expected<std::string> llvm::getBitcodeProducerString(MemoryBufferRef Buffer) {
Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
if (!StreamOrErr)
  return StreamOrErr.takeError();

return readIdentificationCode(*StreamOrErr);
5883}

5885Error llvm::readModuleSummaryIndex(MemoryBufferRef Buffer,
                                 ModuleSummaryIndex &CombinedIndex,
                                 uint64_t ModuleId) {
Expected<BitcodeModule> BM = getSingleModule(Buffer);
if (!BM)
  return BM.takeError();

return BM->readSummary(CombinedIndex, BM->getModuleIdentifier(), ModuleId);
5893}

5895Expected<std::unique_ptr<ModuleSummaryIndex>>
5896llvm::getModuleSummaryIndex(MemoryBufferRef Buffer) {
Expected<BitcodeModule> BM = getSingleModule(Buffer);
if (!BM)
  return BM.takeError();

return BM->getSummary();
5902}

5904Expected<BitcodeLTOInfo> llvm::getBitcodeLTOInfo(MemoryBufferRef Buffer) {
Expected<BitcodeModule> BM = getSingleModule(Buffer);
if (!BM)
  return BM.takeError();

return BM->getLTOInfo();
5910}

5912Expected<std::unique_ptr<ModuleSummaryIndex>>
5913llvm::getModuleSummaryIndexForFile(StringRef Path,
                                 bool IgnoreEmptyThinLTOIndexFile) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
    MemoryBuffer::getFileOrSTDIN(Path);
if (!FileOrErr)
  return errorCodeToError(FileOrErr.getError());
if (IgnoreEmptyThinLTOIndexFile && !(*FileOrErr)->getBufferSize())
  return nullptr;
return getModuleSummaryIndex(**FileOrErr);
5922}

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h

→

1//===- Twine.h - Fast Temporary String Concatenation ------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#ifndef LLVM_ADT_TWINE_H
11#define LLVM_ADT_TWINE_H

13#include "llvm/ADT/SmallVector.h"
14#include "llvm/ADT/StringRef.h"
15#include "llvm/Support/ErrorHandling.h"
16#include <cassert>
17#include <cstdint>
18#include <string>

20namespace llvm {

class formatv_object_base;
class raw_ostream;

/// Twine - A lightweight data structure for efficiently representing the
/// concatenation of temporary values as strings.
///
/// A Twine is a kind of rope, it represents a concatenated string using a
/// binary-tree, where the string is the preorder of the nodes. Since the
/// Twine can be efficiently rendered into a buffer when its result is used,
/// it avoids the cost of generating temporary values for intermediate string
/// results -- particularly in cases when the Twine result is never
/// required. By explicitly tracking the type of leaf nodes, we can also avoid
/// the creation of temporary strings for conversions operations (such as
/// appending an integer to a string).
///
/// A Twine is not intended for use directly and should not be stored, its
/// implementation relies on the ability to store pointers to temporary stack
/// objects which may be deallocated at the end of a statement. Twines should
/// only be used accepted as const references in arguments, when an API wishes
/// to accept possibly-concatenated strings.
///
/// Twines support a special 'null' value, which always concatenates to form
/// itself, and renders as an empty string. This can be returned from APIs to
/// effectively nullify any concatenations performed on the result.
///
/// \b Implementation
///
/// Given the nature of a Twine, it is not possible for the Twine's
/// concatenation method to construct interior nodes; the result must be
/// represented inside the returned value. For this reason a Twine object
/// actually holds two values, the left- and right-hand sides of a
/// concatenation. We also have nullary Twine objects, which are effectively
/// sentinel values that represent empty strings.
///
/// Thus, a Twine can effectively have zero, one, or two children. The \see
/// isNullary(), \see isUnary(), and \see isBinary() predicates exist for
/// testing the number of children.
///
/// We maintain a number of invariants on Twine objects (FIXME: Why):
///  - Nullary twines are always represented with their Kind on the left-hand
///    side, and the Empty kind on the right-hand side.
///  - Unary twines are always represented with the value on the left-hand
///    side, and the Empty kind on the right-hand side.
///  - If a Twine has another Twine as a child, that child should always be
///    binary (otherwise it could have been folded into the parent).
///
/// These invariants are check by \see isValid().
///
/// \b Efficiency Considerations
///
/// The Twine is designed to yield efficient and small code for common
/// situations. For this reason, the concat() method is inlined so that
/// concatenations of leaf nodes can be optimized into stores directly into a
/// single stack allocated object.
///
/// In practice, not all compilers can be trusted to optimize concat() fully,
/// so we provide two additional methods (and accompanying operator+
/// overloads) to guarantee that particularly important cases (cstring plus
/// StringRef) codegen as desired.
class Twine {
  /// NodeKind - Represent the type of an argument.
  enum NodeKind : unsigned char {
    /// An empty string; the result of concatenating anything with it is also
    /// empty.
    NullKind,

    /// The empty string.
    EmptyKind,

    /// A pointer to a Twine instance.
    TwineKind,

    /// A pointer to a C string instance.
    CStringKind,

    /// A pointer to an std::string instance.
    StdStringKind,

    /// A pointer to a StringRef instance.
    StringRefKind,

    /// A pointer to a SmallString instance.
    SmallStringKind,

    /// A pointer to a formatv_object_base instance.
    FormatvObjectKind,

    /// A char value, to render as a character.
    CharKind,

    /// An unsigned int value, to render as an unsigned decimal integer.
    DecUIKind,

    /// An int value, to render as a signed decimal integer.
    DecIKind,

    /// A pointer to an unsigned long value, to render as an unsigned decimal
    /// integer.
    DecULKind,

    /// A pointer to a long value, to render as a signed decimal integer.
    DecLKind,

    /// A pointer to an unsigned long long value, to render as an unsigned
    /// decimal integer.
    DecULLKind,

    /// A pointer to a long long value, to render as a signed decimal integer.
    DecLLKind,

    /// A pointer to a uint64_t value, to render as an unsigned hexadecimal
    /// integer.
    UHexKind
  };

  union Child
  {
    const Twine *twine;
    const char *cString;
    const std::string *stdString;
    const StringRef *stringRef;
    const SmallVectorImpl<char> *smallString;
    const formatv_object_base *formatvObject;
    char character;
    unsigned int decUI;
    int decI;
    const unsigned long *decUL;
    const long *decL;
    const unsigned long long *decULL;
    const long long *decLL;
    const uint64_t *uHex;
  };

  /// LHS - The prefix in the concatenation, which may be uninitialized for
  /// Null or Empty kinds.
  Child LHS;

  /// RHS - The suffix in the concatenation, which may be uninitialized for
  /// Null or Empty kinds.
  Child RHS;

  /// LHSKind - The NodeKind of the left hand side, \see getLHSKind().
  NodeKind LHSKind = EmptyKind;

  /// RHSKind - The NodeKind of the right hand side, \see getRHSKind().
  NodeKind RHSKind = EmptyKind;

  /// Construct a nullary twine; the kind must be NullKind or EmptyKind.
  explicit Twine(NodeKind Kind) : LHSKind(Kind) {
    assert(isNullary() && "Invalid kind!")(static_cast <bool> (isNullary() && "Invalid kind!"
) ? void (0) : __assert_fail ("isNullary() && \"Invalid kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 171, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct a binary twine.
  explicit Twine(const Twine &LHS, const Twine &RHS)
      : LHSKind(TwineKind), RHSKind(TwineKind) {
    this->LHS.twine = &LHS;
    this->RHS.twine = &RHS;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 179, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct a twine from explicit values.
  explicit Twine(Child LHS, NodeKind LHSKind, Child RHS, NodeKind RHSKind)
      : LHS(LHS), RHS(RHS), LHSKind(LHSKind), RHSKind(RHSKind) {
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 185, __extension__ __PRETTY_FUNCTION__));
  }

  /// Check for the null twine.
  bool isNull() const {
    return getLHSKind() == NullKind;
  }

  /// Check for the empty twine.
  bool isEmpty() const {
    return getLHSKind() == EmptyKind;
  }

  /// Check if this is a nullary twine (null or empty).
  bool isNullary() const {
    return isNull() || isEmpty();
  }

  /// Check if this is a unary twine.
  bool isUnary() const {
    return getRHSKind() == EmptyKind && !isNullary();
  }

  /// Check if this is a binary twine.
  bool isBinary() const {
    return getLHSKind() != NullKind && getRHSKind() != EmptyKind;
  }

  /// Check if this is a valid twine (satisfying the invariants on
  /// order and number of arguments).
  bool isValid() const {
    // Nullary twines always have Empty on the RHS.
    if (isNullary() && getRHSKind() != EmptyKind)
      return false;

    // Null should never appear on the RHS.
    if (getRHSKind() == NullKind)
      return false;

    // The RHS cannot be non-empty if the LHS is empty.
    if (getRHSKind() != EmptyKind && getLHSKind() == EmptyKind)
      return false;

    // A twine child should always be binary.
    if (getLHSKind() == TwineKind &&
        !LHS.twine->isBinary())
      return false;
    if (getRHSKind() == TwineKind &&
        !RHS.twine->isBinary())
      return false;

    return true;
  }

  /// Get the NodeKind of the left-hand side.
  NodeKind getLHSKind() const { return LHSKind; }

  /// Get the NodeKind of the right-hand side.
  NodeKind getRHSKind() const { return RHSKind; }

  /// Print one child from a twine.
  void printOneChild(raw_ostream &OS, Child Ptr, NodeKind Kind) const;

  /// Print the representation of one child from a twine.
  void printOneChildRepr(raw_ostream &OS, Child Ptr,
                         NodeKind Kind) const;

public:
  /// @name Constructors
  /// @{

  /// Construct from an empty string.
  /*implicit*/ Twine() {
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 258, __extension__ __PRETTY_FUNCTION__));
  }

  Twine(const Twine &) = default;

  /// Construct from a C string.
  ///
  /// We take care here to optimize "" into the empty twine -- this will be
  /// optimized out for string constants. This allows Twine arguments have
  /// default "" values, without introducing unnecessary string constants.
  /*implicit*/ Twine(const char *Str) {
13
←
Calling implicit default constructor for 'Child'→
14
←
Returning from default constructor for 'Child'→
15
←
Calling implicit default constructor for 'Child'→
16
←
Returning from default constructor for 'Child'→
    if (Str[0] != '\0') {
17
←
Taking true branch→
      LHS.cString = Str;
      LHSKind = CStringKind;
    } else
      LHSKind = EmptyKind;

    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 275, __extension__ __PRETTY_FUNCTION__));
18
←
Within the expansion of the macro 'assert':
→
a
Assuming the condition is true
  }

  /// Construct from an std::string.
  /*implicit*/ Twine(const std::string &Str) : LHSKind(StdStringKind) {
24
←
Calling implicit default constructor for 'Child'→
25
←
Returning from default constructor for 'Child'→
26
←
Calling implicit default constructor for 'Child'→
27
←
Returning from default constructor for 'Child'→
    LHS.stdString = &Str;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 281, __extension__ __PRETTY_FUNCTION__));
28
←
Within the expansion of the macro 'assert':
→
a
Assuming the condition is true
  }

  /// Construct from a StringRef.
  /*implicit*/ Twine(const StringRef &Str) : LHSKind(StringRefKind) {
    LHS.stringRef = &Str;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 287, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct from a SmallString.
  /*implicit*/ Twine(const SmallVectorImpl<char> &Str)
      : LHSKind(SmallStringKind) {
    LHS.smallString = &Str;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 294, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct from a formatv_object_base.
  /*implicit*/ Twine(const formatv_object_base &Fmt)
      : LHSKind(FormatvObjectKind) {
    LHS.formatvObject = &Fmt;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 301, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct from a char.
  explicit Twine(char Val) : LHSKind(CharKind) {
    LHS.character = Val;
  }

  /// Construct from a signed char.
  explicit Twine(signed char Val) : LHSKind(CharKind) {
    LHS.character = static_cast<char>(Val);
  }

  /// Construct from an unsigned char.
  explicit Twine(unsigned char Val) : LHSKind(CharKind) {
    LHS.character = static_cast<char>(Val);
  }

  /// Construct a twine to print \p Val as an unsigned decimal integer.
  explicit Twine(unsigned Val) : LHSKind(DecUIKind) {
    LHS.decUI = Val;
  }

  /// Construct a twine to print \p Val as a signed decimal integer.
  explicit Twine(int Val) : LHSKind(DecIKind) {
    LHS.decI = Val;
  }

  /// Construct a twine to print \p Val as an unsigned decimal integer.
  explicit Twine(const unsigned long &Val) : LHSKind(DecULKind) {
    LHS.decUL = &Val;
  }

  /// Construct a twine to print \p Val as a signed decimal integer.
  explicit Twine(const long &Val) : LHSKind(DecLKind) {
    LHS.decL = &Val;
  }

  /// Construct a twine to print \p Val as an unsigned decimal integer.
  explicit Twine(const unsigned long long &Val) : LHSKind(DecULLKind) {
    LHS.decULL = &Val;
  }

  /// Construct a twine to print \p Val as a signed decimal integer.
  explicit Twine(const long long &Val) : LHSKind(DecLLKind) {
    LHS.decLL = &Val;
  }

  // FIXME: Unfortunately, to make sure this is as efficient as possible we
  // need extra binary constructors from particular types. We can't rely on
  // the compiler to be smart enough to fold operator+()/concat() down to the
  // right thing. Yet.

  /// Construct as the concatenation of a C string and a StringRef.
  /*implicit*/ Twine(const char *LHS, const StringRef &RHS)
      : LHSKind(CStringKind), RHSKind(StringRefKind) {
    this->LHS.cString = LHS;
    this->RHS.stringRef = &RHS;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 359, __extension__ __PRETTY_FUNCTION__));
  }

  /// Construct as the concatenation of a StringRef and a C string.
  /*implicit*/ Twine(const StringRef &LHS, const char *RHS)
      : LHSKind(StringRefKind), RHSKind(CStringKind) {
    this->LHS.stringRef = &LHS;
    this->RHS.cString = RHS;
    assert(isValid() && "Invalid twine!")(static_cast <bool> (isValid() && "Invalid twine!"
) ? void (0) : __assert_fail ("isValid() && \"Invalid twine!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 367, __extension__ __PRETTY_FUNCTION__));
  }

  /// Since the intended use of twines is as temporary objects, assignments
  /// when concatenating might cause undefined behavior or stack corruptions
  Twine &operator=(const Twine &) = delete;

  /// Create a 'null' string, which is an empty string that always
  /// concatenates to form another empty string.
  static Twine createNull() {
    return Twine(NullKind);
  }

  /// @}
  /// @name Numeric Conversions
  /// @{

  // Construct a twine to print \p Val as an unsigned hexadecimal integer.
  static Twine utohexstr(const uint64_t &Val) {
    Child LHS, RHS;
    LHS.uHex = &Val;
    RHS.twine = nullptr;
    return Twine(LHS, UHexKind, RHS, EmptyKind);
  }

  /// @}
  /// @name Predicate Operations
  /// @{

  /// Check if this twine is trivially empty; a false return value does not
  /// necessarily mean the twine is empty.
  bool isTriviallyEmpty() const {
    return isNullary();
  }

  /// Return true if this twine can be dynamically accessed as a single
  /// StringRef value with getSingleStringRef().
  bool isSingleStringRef() const {
    if (getRHSKind() != EmptyKind) return false;

    switch (getLHSKind()) {
    case EmptyKind:
    case CStringKind:
    case StdStringKind:
    case StringRefKind:
    case SmallStringKind:
      return true;
    default:
      return false;
    }
  }

  /// @}
  /// @name String Operations
  /// @{

  Twine concat(const Twine &Suffix) const;

  /// @}
  /// @name Output & Conversion.
  /// @{

  /// Return the twine contents as a std::string.
  std::string str() const;

  /// Append the concatenated string into the given SmallString or SmallVector.
  void toVector(SmallVectorImpl<char> &Out) const;

  /// This returns the twine as a single StringRef.  This method is only valid
  /// if isSingleStringRef() is true.
  StringRef getSingleStringRef() const {
    assert(isSingleStringRef() &&"This cannot be had as a single stringref!")(static_cast <bool> (isSingleStringRef() &&"This cannot be had as a single stringref!"
) ? void (0) : __assert_fail ("isSingleStringRef() &&\"This cannot be had as a single stringref!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 438, __extension__ __PRETTY_FUNCTION__));
    switch (getLHSKind()) {
    default: llvm_unreachable("Out of sync with isSingleStringRef")::llvm::llvm_unreachable_internal("Out of sync with isSingleStringRef"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/Twine.h"
, 440);
    case EmptyKind:      return StringRef();
    case CStringKind:    return StringRef(LHS.cString);
    case StdStringKind:  return StringRef(*LHS.stdString);
    case StringRefKind:  return *LHS.stringRef;
    case SmallStringKind:
      return StringRef(LHS.smallString->data(), LHS.smallString->size());
    }
  }

  /// This returns the twine as a single StringRef if it can be
  /// represented as such. Otherwise the twine is written into the given
  /// SmallVector and a StringRef to the SmallVector's data is returned.
  StringRef toStringRef(SmallVectorImpl<char> &Out) const {
    if (isSingleStringRef())
      return getSingleStringRef();
    toVector(Out);
    return StringRef(Out.data(), Out.size());
  }

  /// This returns the twine as a single null terminated StringRef if it
  /// can be represented as such. Otherwise the twine is written into the
  /// given SmallVector and a StringRef to the SmallVector's data is returned.
  ///
  /// The returned StringRef's size does not include the null terminator.
  StringRef toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const;

  /// Write the concatenated string represented by this twine to the
  /// stream \p OS.
  void print(raw_ostream &OS) const;

  /// Dump the concatenated string represented by this twine to stderr.
  void dump() const;

  /// Write the representation of this twine to the stream \p OS.
  void printRepr(raw_ostream &OS) const;

  /// Dump the representation of this twine to stderr.
  void dumpRepr() const;

  /// @}
};

/// @name Twine Inline Implementations
/// @{

inline Twine Twine::concat(const Twine &Suffix) const {
  // Concatenation with null is null.
  if (isNull() || Suffix.isNull())
    return Twine(NullKind);

  // Concatenation with empty yields the other side.
  if (isEmpty())
    return Suffix;
  if (Suffix.isEmpty())
    return *this;

  // Otherwise we need to create a new node, taking care to fold in unary
  // twines.
  Child NewLHS, NewRHS;
  NewLHS.twine = this;
  NewRHS.twine = &Suffix;
  NodeKind NewLHSKind = TwineKind, NewRHSKind = TwineKind;
  if (isUnary()) {
    NewLHS = LHS;
    NewLHSKind = getLHSKind();
  }
  if (Suffix.isUnary()) {
    NewRHS = Suffix.LHS;
    NewRHSKind = Suffix.getLHSKind();
  }

  return Twine(NewLHS, NewLHSKind, NewRHS, NewRHSKind);
}

inline Twine operator+(const Twine &LHS, const Twine &RHS) {
  return LHS.concat(RHS);
}

/// Additional overload to guarantee simplified codegen; this is equivalent to
/// concat().

inline Twine operator+(const char *LHS, const StringRef &RHS) {
  return Twine(LHS, RHS);
}

/// Additional overload to guarantee simplified codegen; this is equivalent to
/// concat().

inline Twine operator+(const StringRef &LHS, const char *RHS) {
  return Twine(LHS, RHS);
}

inline raw_ostream &operator<<(raw_ostream &OS, const Twine &RHS) {
  RHS.print(OS);
  return OS;
}

/// @}

540} // end namespace llvm

542#endif // LLVM_ADT_TWINE_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Bitcode/BitcodeReader.h

→

1//===- llvm/Bitcode/BitcodeReader.h - Bitcode reader ------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This header defines interfaces to read LLVM bitcode files/streams.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_BITCODE_BITCODEREADER_H
15#define LLVM_BITCODE_BITCODEREADER_H

17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/Bitcode/BitCodes.h"
20#include "llvm/IR/ModuleSummaryIndex.h"
21#include "llvm/Support/Endian.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/ErrorOr.h"
24#include "llvm/Support/MemoryBuffer.h"
25#include <cstdint>
26#include <memory>
27#include <string>
28#include <system_error>
29#include <vector>
30namespace llvm {

32class LLVMContext;
33class Module;

// These functions are for converting Expected/Error values to
// ErrorOr/std::error_code for compatibility with legacy clients. FIXME:
// Remove these functions once no longer needed by the C and libLTO APIs.

std::error_code errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err);

template <typename T>
ErrorOr<T> expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected<T> Val) {
  if (!Val)
    return errorToErrorCodeAndEmitErrors(Ctx, Val.takeError());
  return std::move(*Val);
}

struct BitcodeFileContents;

/// Basic information extracted from a bitcode module to be used for LTO.
struct BitcodeLTOInfo {
  bool IsThinLTO;
  bool HasSummary;
};

/// Represents a module in a bitcode file.
class BitcodeModule {
  // This covers the identification (if present) and module blocks.
  ArrayRef<uint8_t> Buffer;
  StringRef ModuleIdentifier;

  // The string table used to interpret this module.
  StringRef Strtab;

  // The bitstream location of the IDENTIFICATION_BLOCK.
  uint64_t IdentificationBit;

  // The bitstream location of this module's MODULE_BLOCK.
  uint64_t ModuleBit;

  BitcodeModule(ArrayRef<uint8_t> Buffer, StringRef ModuleIdentifier,
                uint64_t IdentificationBit, uint64_t ModuleBit)
      : Buffer(Buffer), ModuleIdentifier(ModuleIdentifier),
        IdentificationBit(IdentificationBit), ModuleBit(ModuleBit) {}

  // Calls the ctor.
  friend Expected<BitcodeFileContents>
  getBitcodeFileContents(MemoryBufferRef Buffer);

  Expected<std::unique_ptr<Module>> getModuleImpl(LLVMContext &Context,
                                                  bool MaterializeAll,
                                                  bool ShouldLazyLoadMetadata,
                                                  bool IsImporting);

public:
  StringRef getBuffer() const {
    return StringRef((const char *)Buffer.begin(), Buffer.size());
  }

  StringRef getStrtab() const { return Strtab; }

  StringRef getModuleIdentifier() const { return ModuleIdentifier; }

  /// Read the bitcode module and prepare for lazy deserialization of function
  /// bodies. If ShouldLazyLoadMetadata is true, lazily load metadata as well.
  /// If IsImporting is true, this module is being parsed for ThinLTO
  /// importing into another module.
  Expected<std::unique_ptr<Module>> getLazyModule(LLVMContext &Context,
                                                  bool ShouldLazyLoadMetadata,
                                                  bool IsImporting);

  /// Read the entire bitcode module and return it.
  Expected<std::unique_ptr<Module>> parseModule(LLVMContext &Context);

  /// Returns information about the module to be used for LTO: whether to
  /// compile with ThinLTO, and whether it has a summary.
  Expected<BitcodeLTOInfo> getLTOInfo();

  /// Parse the specified bitcode buffer, returning the module summary index.
  Expected<std::unique_ptr<ModuleSummaryIndex>> getSummary();

  /// Parse the specified bitcode buffer and merge its module summary index
  /// into CombinedIndex.
  Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath,
                    uint64_t ModuleId);
};

struct BitcodeFileContents {
  std::vector<BitcodeModule> Mods;
  StringRef Symtab, StrtabForSymtab;
};

/// Returns the contents of a bitcode file. This includes the raw contents of
/// the symbol table embedded in the bitcode file. Clients which require a
/// symbol table should prefer to use irsymtab::read instead of this function
/// because it creates a reader for the irsymtab and handles upgrading bitcode
/// files without a symbol table or with an old symbol table.
Expected<BitcodeFileContents> getBitcodeFileContents(MemoryBufferRef Buffer);

/// Returns a list of modules in the specified bitcode buffer.
Expected<std::vector<BitcodeModule>>
getBitcodeModuleList(MemoryBufferRef Buffer);

/// Read the header of the specified bitcode buffer and prepare for lazy
/// deserialization of function bodies. If ShouldLazyLoadMetadata is true,
/// lazily load metadata as well. If IsImporting is true, this module is
/// being parsed for ThinLTO importing into another module.
Expected<std::unique_ptr<Module>>
getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context,
                     bool ShouldLazyLoadMetadata = false,
                     bool IsImporting = false);

/// Like getLazyBitcodeModule, except that the module takes ownership of
/// the memory buffer if successful. If successful, this moves Buffer. On
/// error, this *does not* move Buffer. If IsImporting is true, this module is
/// being parsed for ThinLTO importing into another module.
Expected<std::unique_ptr<Module>> getOwningLazyBitcodeModule(
    std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
    bool ShouldLazyLoadMetadata = false, bool IsImporting = false);

/// Read the header of the specified bitcode buffer and extract just the
/// triple information. If successful, this returns a string. On error, this
/// returns "".
Expected<std::string> getBitcodeTargetTriple(MemoryBufferRef Buffer);

/// Return true if \p Buffer contains a bitcode file with ObjC code (category
/// or class) in it.
Expected<bool> isBitcodeContainingObjCCategory(MemoryBufferRef Buffer);

/// Read the header of the specified bitcode buffer and extract just the
/// producer string information. If successful, this returns a string. On
/// error, this returns "".
Expected<std::string> getBitcodeProducerString(MemoryBufferRef Buffer);

/// Read the specified bitcode file, returning the module.
Expected<std::unique_ptr<Module>> parseBitcodeFile(MemoryBufferRef Buffer,
                                                   LLVMContext &Context);

/// Returns LTO information for the specified bitcode file.
Expected<BitcodeLTOInfo> getBitcodeLTOInfo(MemoryBufferRef Buffer);

/// Parse the specified bitcode buffer, returning the module summary index.
Expected<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndex(MemoryBufferRef Buffer);

/// Parse the specified bitcode buffer and merge the index into CombinedIndex.
Error readModuleSummaryIndex(MemoryBufferRef Buffer,
                             ModuleSummaryIndex &CombinedIndex,
                             uint64_t ModuleId);

/// Parse the module summary index out of an IR file and return the module
/// summary index object if found, or an empty summary if not. If Path refers
/// to an empty file and IgnoreEmptyThinLTOIndexFile is true, then
/// this function will return nullptr.
Expected<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndexForFile(StringRef Path,
                             bool IgnoreEmptyThinLTOIndexFile = false);

/// isBitcodeWrapper - Return true if the given bytes are the magic bytes
/// for an LLVM IR bitcode wrapper.
inline bool isBitcodeWrapper(const unsigned char *BufPtr,
                             const unsigned char *BufEnd) {
  // See if you can find the hidden message in the magic bytes :-).
  // (Hint: it's a little-endian encoding.)
  return BufPtr != BufEnd &&
         BufPtr[0] == 0xDE &&
         BufPtr[1] == 0xC0 &&
         BufPtr[2] == 0x17 &&
         BufPtr[3] == 0x0B;
}

/// isRawBitcode - Return true if the given bytes are the magic bytes for
/// raw LLVM IR bitcode (without a wrapper).
inline bool isRawBitcode(const unsigned char *BufPtr,
                         const unsigned char *BufEnd) {
  // These bytes sort of have a hidden message, but it's not in
  // little-endian this time, and it's a little redundant.
  return BufPtr != BufEnd &&
         BufPtr[0] == 'B' &&
         BufPtr[1] == 'C' &&
         BufPtr[2] == 0xc0 &&
         BufPtr[3] == 0xde;
}

/// isBitcode - Return true if the given bytes are the magic bytes for
/// LLVM IR bitcode, either with or without a wrapper.
inline bool isBitcode(const unsigned char *BufPtr,
                      const unsigned char *BufEnd) {
  return isBitcodeWrapper(BufPtr, BufEnd) ||
         isRawBitcode(BufPtr, BufEnd);
}

/// SkipBitcodeWrapperHeader - Some systems wrap bc files with a special
/// header for padding or other reasons.  The format of this header is:
///
/// struct bc_header {
///   uint32_t Magic;         // 0x0B17C0DE
///   uint32_t Version;       // Version, currently always 0.
///   uint32_t BitcodeOffset; // Offset to traditional bitcode file.
///   uint32_t BitcodeSize;   // Size of traditional bitcode file.
///   ... potentially other gunk ...
/// };
///
/// This function is called when we find a file with a matching magic number.
/// In this case, skip down to the subsection of the file that is actually a
/// BC file.
/// If 'VerifyBufferSize' is true, check that the buffer is large enough to
/// contain the whole bitcode file.
inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr,
                                     const unsigned char *&BufEnd,
                                     bool VerifyBufferSize) {
  // Must contain the offset and size field!
  if (unsigned(BufEnd - BufPtr) < BWH_SizeField + 4)
    return true;

  unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
  unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
  uint64_t BitcodeOffsetEnd = (uint64_t)Offset + (uint64_t)Size;

  // Verify that Offset+Size fits in the file.
  if (VerifyBufferSize && BitcodeOffsetEnd > uint64_t(BufEnd-BufPtr))
    return true;
  BufPtr += Offset;
  BufEnd = BufPtr+Size;
  return false;
}

const std::error_category &BitcodeErrorCategory();
enum class BitcodeError { CorruptedBitcode = 1 };
inline std::error_code make_error_code(BitcodeError E) {
  return std::error_code(static_cast<int>(E), BitcodeErrorCategory());
32
←
Calling 'BitcodeErrorCategory'→
49
←
Returning from 'BitcodeErrorCategory'→
50
←
Calling constructor for 'error_code'→
51
←
Returning from constructor for 'error_code'→
}

264} // end namespace llvm

266namespace std {

268template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {};

270} // end namespace std

272#endif // LLVM_BITCODE_BITCODEREADER_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/ManagedStatic.h

→

1//===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the ManagedStatic class and the llvm_shutdown() function.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_MANAGEDSTATIC_H
15#define LLVM_SUPPORT_MANAGEDSTATIC_H
16 
17#include <atomic>
18#include <cstddef>
19 
20namespace llvm {
21 
22/// object_creator - Helper method for ManagedStatic.
23template <class C> struct object_creator {
24  static void *call() { return new C(); }
25};
26 
27/// object_deleter - Helper method for ManagedStatic.
28///
29template <typename T> struct object_deleter {
30  static void call(void *Ptr) { delete (T *)Ptr; }
31};
32template <typename T, size_t N> struct object_deleter<T[N]> {
33  static void call(void *Ptr) { delete[](T *)Ptr; }
34};
35 
36/// ManagedStaticBase - Common base class for ManagedStatic instances.
37class ManagedStaticBase {
38protected:
39  // This should only be used as a static variable, which guarantees that this
40  // will be zero initialized.
41  mutable std::atomic<void *> Ptr;
42  mutable void (*DeleterFn)(void*);
43  mutable const ManagedStaticBase *Next;
44 
45  void RegisterManagedStatic(void *(*creator)(), void (*deleter)(void*)) const;
46 
47public:
48  /// isConstructed - Return true if this object has not been created yet.
49  bool isConstructed() const { return Ptr != nullptr; }
50 
51  void destroy() const;
52};
53 
54/// ManagedStatic - This transparently changes the behavior of global statics to
55/// be lazily constructed on demand (good for reducing startup times of dynamic
56/// libraries that link in LLVM components) and for making destruction be
57/// explicit through the llvm_shutdown() function call.
58///
59template <class C, class Creator = object_creator<C>,
60          class Deleter = object_deleter<C>>
61class ManagedStatic : public ManagedStaticBase {
62public:
63  // Accessors.
64  C &operator*() {
65    void *Tmp = Ptr.load(std::memory_order_acquire);
34
←
Calling 'atomic::load'→
39
←
Returning from 'atomic::load'→
66    if (!Tmp)
40
←
Assuming 'Tmp' is non-null→
41
←
Taking false branch→
67      RegisterManagedStatic(Creator::call, Deleter::call);
68 
69    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
42
←
Calling 'atomic::load'→
47
←
Returning from 'atomic::load'→
70  }
71 
72  C *operator->() { return &**this; }
73 
74  const C &operator*() const {
75    void *Tmp = Ptr.load(std::memory_order_acquire);
76    if (!Tmp)
77      RegisterManagedStatic(Creator::call, Deleter::call);
78 
79    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
80  }
81 
82  const C *operator->() const { return &**this; }
83};
84 
85/// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
86void llvm_shutdown();
87 
88/// llvm_shutdown_obj - This is a simple helper class that calls
89/// llvm_shutdown() when it is destroyed.
90struct llvm_shutdown_obj {
91  llvm_shutdown_obj() = default;
92  ~llvm_shutdown_obj() { llvm_shutdown(); }
93};
94 
95} // end namespace llvm
96 
97#endif // LLVM_SUPPORT_MANAGEDSTATIC_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/atomic

→

1// -*- C++ -*- header.

3// Copyright (C) 2008-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file include/atomic
*  This is a Standard C++ Library header.
*/

29// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
30// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html

32#ifndef _GLIBCXX_ATOMIC1
33#define _GLIBCXX_ATOMIC1 1

35#pragma GCC system_header

37#if __cplusplus201103L < 201103L
38# include <bits/c++0x_warning.h>
39#else

41#include <bits/atomic_base.h>
42#include <bits/move.h>

44namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
45{
46_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup atomics
 * @{
 */

53#if __cplusplus201103L > 201402L
54# define __cpp_lib_atomic_is_always_lock_free 201603
55#endif

template<typename _Tp>
  struct atomic;

/// atomic<bool>
// NB: No operators or fetch-operations for this type.
template<>
struct atomic<bool>
{
private:
  __atomic_base<bool>	_M_base;

public:
  atomic() noexcept = default;
  ~atomic() noexcept = default;
  atomic(const atomic&) = delete;
  atomic& operator=(const atomic&) = delete;
  atomic& operator=(const atomic&) volatile = delete;

  constexpr atomic(bool __i) noexcept : _M_base(__i) { }

  bool
  operator=(bool __i) noexcept
  { return _M_base.operator=(__i); }

  bool
  operator=(bool __i) volatile noexcept
  { return _M_base.operator=(__i); }

  operator bool() const noexcept
  { return _M_base.load(); }

  operator bool() const volatile noexcept
  { return _M_base.load(); }

  bool
  is_lock_free() const noexcept { return _M_base.is_lock_free(); }

  bool
  is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }

97#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE2 == 2;
99#endif

  void
  store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
  { _M_base.store(__i, __m); }

  void
  store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
  { _M_base.store(__i, __m); }

  bool
  load(memory_order __m = memory_order_seq_cst) const noexcept
  { return _M_base.load(__m); }

  bool
  load(memory_order __m = memory_order_seq_cst) const volatile noexcept
  { return _M_base.load(__m); }

  bool
  exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
  { return _M_base.exchange(__i, __m); }

  bool
  exchange(bool __i,
    memory_order __m = memory_order_seq_cst) volatile noexcept
  { return _M_base.exchange(__i, __m); }

  bool
  compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
	  memory_order __m2) noexcept
  { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

  bool
  compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
	  memory_order __m2) volatile noexcept
  { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

  bool
  compare_exchange_weak(bool& __i1, bool __i2,
	  memory_order __m = memory_order_seq_cst) noexcept
  { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

  bool
  compare_exchange_weak(bool& __i1, bool __i2,
     memory_order __m = memory_order_seq_cst) volatile noexcept
  { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

  bool
  compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
	    memory_order __m2) noexcept
  { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

  bool
  compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
	    memory_order __m2) volatile noexcept
  { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

  bool
  compare_exchange_strong(bool& __i1, bool __i2,
	    memory_order __m = memory_order_seq_cst) noexcept
  { return _M_base.compare_exchange_strong(__i1, __i2, __m); }

  bool
  compare_exchange_strong(bool& __i1, bool __i2,
    memory_order __m = memory_order_seq_cst) volatile noexcept
  { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
};


/**
 *  @brief Generic atomic type, primary class template.
 *
 *  @tparam _Tp  Type to be made atomic, must be trivally copyable.
 */
template<typename _Tp>
  struct atomic
  {
  private:
    // Align 1/2/4/8/16-byte types to at least their size.
    static constexpr int _S_min_alignment
= (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
? 0 : sizeof(_Tp);

    static constexpr int _S_alignment
      = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);

    alignas(_S_alignment) _Tp _M_i;

    static_assert(__is_trivially_copyable(_Tp),
    "std::atomic requires a trivially copyable type");

    static_assert(sizeof(_Tp) > 0,
    "Incomplete or zero-sized types are not supported");

  public:
    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }

    operator _Tp() const noexcept
    { return load(); }

    operator _Tp() const volatile noexcept
    { return load(); }

    _Tp
    operator=(_Tp __i) noexcept
    { store(__i); return __i; }

    _Tp
    operator=(_Tp __i) volatile noexcept
    { store(__i); return __i; }

    bool
    is_lock_free() const noexcept
    {
// Produce a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_i),
   reinterpret_cast<void *>(-__alignof(_M_i)));
    }

    bool
    is_lock_free() const volatile noexcept
    {
// Produce a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_i),
   reinterpret_cast<void *>(-__alignof(_M_i)));
    }

232#if __cplusplus201103L > 201402L
    static constexpr bool is_always_lock_free
= __atomic_always_lock_free(sizeof(_M_i), 0);
235#endif

    void
    store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
    { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __m); }

    void
    store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
    { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __m); }

    _Tp
    load(memory_order __m = memory_order_seq_cst) const noexcept
    {
alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
__atomic_load(std::__addressof(_M_i), __ptr, __m);
return *__ptr;
    }

    _Tp
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    {
      alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
__atomic_load(std::__addressof(_M_i), __ptr, __m);
return *__ptr;
    }

    _Tp
    exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
    {
      alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
	  __ptr, __m);
return *__ptr;
    }

    _Tp
    exchange(_Tp __i,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    {
      alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
	  __ptr, __m);
return *__ptr;
    }

    bool
    compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
	    memory_order __f) noexcept
    {
return __atomic_compare_exchange(std::__addressof(_M_i),
			 std::__addressof(__e),
			 std::__addressof(__i),
			 true, __s, __f);
    }

    bool
    compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
	    memory_order __f) volatile noexcept
    {
return __atomic_compare_exchange(std::__addressof(_M_i),
			 std::__addressof(__e),
			 std::__addressof(__i),
			 true, __s, __f);
    }

    bool
    compare_exchange_weak(_Tp& __e, _Tp __i,
	    memory_order __m = memory_order_seq_cst) noexcept
    { return compare_exchange_weak(__e, __i, __m,
                                   __cmpexch_failure_order(__m)); }

    bool
    compare_exchange_weak(_Tp& __e, _Tp __i,
     memory_order __m = memory_order_seq_cst) volatile noexcept
    { return compare_exchange_weak(__e, __i, __m,
                                   __cmpexch_failure_order(__m)); }

    bool
    compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
	      memory_order __f) noexcept
    {
return __atomic_compare_exchange(std::__addressof(_M_i),
			 std::__addressof(__e),
			 std::__addressof(__i),
			 false, __s, __f);
    }

    bool
    compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
	      memory_order __f) volatile noexcept
    {
return __atomic_compare_exchange(std::__addressof(_M_i),
			 std::__addressof(__e),
			 std::__addressof(__i),
			 false, __s, __f);
    }

    bool
    compare_exchange_strong(_Tp& __e, _Tp __i,
	       memory_order __m = memory_order_seq_cst) noexcept
    { return compare_exchange_strong(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }

    bool
    compare_exchange_strong(_Tp& __e, _Tp __i,
     memory_order __m = memory_order_seq_cst) volatile noexcept
    { return compare_exchange_strong(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }
  };


/// Partial specialization for pointer types.
template<typename _Tp>
  struct atomic<_Tp*>
  {
    typedef _Tp* 			__pointer_type;
    typedef __atomic_base<_Tp*>	__base_type;
    __base_type			_M_b;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }

    operator __pointer_type() const noexcept
    { return __pointer_type(_M_b); }

    operator __pointer_type() const volatile noexcept
    { return __pointer_type(_M_b); }

    __pointer_type
    operator=(__pointer_type __p) noexcept
    { return _M_b.operator=(__p); }

    __pointer_type
    operator=(__pointer_type __p) volatile noexcept
    { return _M_b.operator=(__p); }

    __pointer_type
    operator++(int) noexcept
    { return _M_b++; }

    __pointer_type
    operator++(int) volatile noexcept
    { return _M_b++; }

    __pointer_type
    operator--(int) noexcept
    { return _M_b--; }

    __pointer_type
    operator--(int) volatile noexcept
    { return _M_b--; }

    __pointer_type
    operator++() noexcept
    { return ++_M_b; }

    __pointer_type
    operator++() volatile noexcept
    { return ++_M_b; }

    __pointer_type
    operator--() noexcept
    { return --_M_b; }

    __pointer_type
    operator--() volatile noexcept
    { return --_M_b; }

    __pointer_type
    operator+=(ptrdiff_t __d) noexcept
    { return _M_b.operator+=(__d); }

    __pointer_type
    operator+=(ptrdiff_t __d) volatile noexcept
    { return _M_b.operator+=(__d); }

    __pointer_type
    operator-=(ptrdiff_t __d) noexcept
    { return _M_b.operator-=(__d); }

    __pointer_type
    operator-=(ptrdiff_t __d) volatile noexcept
    { return _M_b.operator-=(__d); }

    bool
    is_lock_free() const noexcept
    { return _M_b.is_lock_free(); }

    bool
    is_lock_free() const volatile noexcept
    { return _M_b.is_lock_free(); }

436#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE2 == 2;
438#endif

    void
    store(__pointer_type __p,
   memory_order __m = memory_order_seq_cst) noexcept
    { return _M_b.store(__p, __m); }

    void
    store(__pointer_type __p,
   memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_b.store(__p, __m); }

    __pointer_type
    load(memory_order __m = memory_order_seq_cst) const noexcept
    { return _M_b.load(__m); }
35
←
Calling '__atomic_base::load'→
38
←
Returning from '__atomic_base::load'→
43
←
Calling '__atomic_base::load'→
46
←
Returning from '__atomic_base::load'→

    __pointer_type
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    { return _M_b.load(__m); }

    __pointer_type
    exchange(__pointer_type __p,
      memory_order __m = memory_order_seq_cst) noexcept
    { return _M_b.exchange(__p, __m); }

    __pointer_type
    exchange(__pointer_type __p,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_b.exchange(__p, __m); }

    bool
    compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
	    memory_order __m1, memory_order __m2) noexcept
    { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

    bool
    compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
	    memory_order __m1,
	    memory_order __m2) volatile noexcept
    { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

    bool
    compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
	    memory_order __m = memory_order_seq_cst) noexcept
    {
return compare_exchange_weak(__p1, __p2, __m,
		     __cmpexch_failure_order(__m));
    }

    bool
    compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
    memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return compare_exchange_weak(__p1, __p2, __m,
		     __cmpexch_failure_order(__m));
    }

    bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
	      memory_order __m1, memory_order __m2) noexcept
    { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

    bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
	      memory_order __m1,
	      memory_order __m2) volatile noexcept
    { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

    bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
	      memory_order __m = memory_order_seq_cst) noexcept
    {
return _M_b.compare_exchange_strong(__p1, __p2, __m,
			    __cmpexch_failure_order(__m));
    }

    bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
    memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return _M_b.compare_exchange_strong(__p1, __p2, __m,
			    __cmpexch_failure_order(__m));
    }

    __pointer_type
    fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
    { return _M_b.fetch_add(__d, __m); }

    __pointer_type
    fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_b.fetch_add(__d, __m); }

    __pointer_type
    fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
    { return _M_b.fetch_sub(__d, __m); }

    __pointer_type
    fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_b.fetch_sub(__d, __m); }
  };


/// Explicit specialization for char.
template<>
  struct atomic<char> : __atomic_base<char>
  {
    typedef char 			__integral_type;
    typedef __atomic_base<char> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

562#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE2 == 2;
564#endif
  };

/// Explicit specialization for signed char.
template<>
  struct atomic<signed char> : __atomic_base<signed char>
  {
    typedef signed char 		__integral_type;
    typedef __atomic_base<signed char> 	__base_type;

    atomic() noexcept= default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

585#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE2 == 2;
587#endif
  };

/// Explicit specialization for unsigned char.
template<>
  struct atomic<unsigned char> : __atomic_base<unsigned char>
  {
    typedef unsigned char 		__integral_type;
    typedef __atomic_base<unsigned char> 	__base_type;

    atomic() noexcept= default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

608#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE2 == 2;
610#endif
  };

/// Explicit specialization for short.
template<>
  struct atomic<short> : __atomic_base<short>
  {
    typedef short 			__integral_type;
    typedef __atomic_base<short> 		__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

631#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE2 == 2;
633#endif
  };

/// Explicit specialization for unsigned short.
template<>
  struct atomic<unsigned short> : __atomic_base<unsigned short>
  {
    typedef unsigned short 	      	__integral_type;
    typedef __atomic_base<unsigned short> 		__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

654#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE2 == 2;
656#endif
  };

/// Explicit specialization for int.
template<>
  struct atomic<int> : __atomic_base<int>
  {
    typedef int 			__integral_type;
    typedef __atomic_base<int> 		__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

677#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE2 == 2;
679#endif
  };

/// Explicit specialization for unsigned int.
template<>
  struct atomic<unsigned int> : __atomic_base<unsigned int>
  {
    typedef unsigned int		__integral_type;
    typedef __atomic_base<unsigned int> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

700#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE2 == 2;
702#endif
  };

/// Explicit specialization for long.
template<>
  struct atomic<long> : __atomic_base<long>
  {
    typedef long 			__integral_type;
    typedef __atomic_base<long> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

723#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE2 == 2;
725#endif
  };

/// Explicit specialization for unsigned long.
template<>
  struct atomic<unsigned long> : __atomic_base<unsigned long>
  {
    typedef unsigned long 		__integral_type;
    typedef __atomic_base<unsigned long> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

746#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE2 == 2;
748#endif
  };

/// Explicit specialization for long long.
template<>
  struct atomic<long long> : __atomic_base<long long>
  {
    typedef long long 		__integral_type;
    typedef __atomic_base<long long> 		__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

769#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE2 == 2;
771#endif
  };

/// Explicit specialization for unsigned long long.
template<>
  struct atomic<unsigned long long> : __atomic_base<unsigned long long>
  {
    typedef unsigned long long       	__integral_type;
    typedef __atomic_base<unsigned long long> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

792#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE2 == 2;
794#endif
  };

/// Explicit specialization for wchar_t.
template<>
  struct atomic<wchar_t> : __atomic_base<wchar_t>
  {
    typedef wchar_t 			__integral_type;
    typedef __atomic_base<wchar_t> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

815#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE2 == 2;
817#endif
  };

/// Explicit specialization for char16_t.
template<>
  struct atomic<char16_t> : __atomic_base<char16_t>
  {
    typedef char16_t 			__integral_type;
    typedef __atomic_base<char16_t> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

838#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE2 == 2;
840#endif
  };

/// Explicit specialization for char32_t.
template<>
  struct atomic<char32_t> : __atomic_base<char32_t>
  {
    typedef char32_t 			__integral_type;
    typedef __atomic_base<char32_t> 	__base_type;

    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

    using __base_type::operator __integral_type;
    using __base_type::operator=;

861#if __cplusplus201103L > 201402L
  static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE2 == 2;
863#endif
  };


/// atomic_bool
typedef atomic<bool>			atomic_bool;

/// atomic_char
typedef atomic<char>			atomic_char;

/// atomic_schar
typedef atomic<signed char>		atomic_schar;

/// atomic_uchar
typedef atomic<unsigned char>		atomic_uchar;

/// atomic_short
typedef atomic<short>			atomic_short;

/// atomic_ushort
typedef atomic<unsigned short>	atomic_ushort;

/// atomic_int
typedef atomic<int>			atomic_int;

/// atomic_uint
typedef atomic<unsigned int>		atomic_uint;

/// atomic_long
typedef atomic<long>			atomic_long;

/// atomic_ulong
typedef atomic<unsigned long>		atomic_ulong;

/// atomic_llong
typedef atomic<long long>		atomic_llong;

/// atomic_ullong
typedef atomic<unsigned long long>	atomic_ullong;

/// atomic_wchar_t
typedef atomic<wchar_t>		atomic_wchar_t;

/// atomic_char16_t
typedef atomic<char16_t>		atomic_char16_t;

/// atomic_char32_t
typedef atomic<char32_t>		atomic_char32_t;


// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2441. Exact-width atomic typedefs should be provided

/// atomic_int8_t
typedef atomic<int8_t>		atomic_int8_t;

/// atomic_uint8_t
typedef atomic<uint8_t>		atomic_uint8_t;

/// atomic_int16_t
typedef atomic<int16_t>		atomic_int16_t;

/// atomic_uint16_t
typedef atomic<uint16_t>		atomic_uint16_t;

/// atomic_int32_t
typedef atomic<int32_t>		atomic_int32_t;

/// atomic_uint32_t
typedef atomic<uint32_t>		atomic_uint32_t;

/// atomic_int64_t
typedef atomic<int64_t>		atomic_int64_t;

/// atomic_uint64_t
typedef atomic<uint64_t>		atomic_uint64_t;


/// atomic_int_least8_t
typedef atomic<int_least8_t>		atomic_int_least8_t;

/// atomic_uint_least8_t
typedef atomic<uint_least8_t>		atomic_uint_least8_t;

/// atomic_int_least16_t
typedef atomic<int_least16_t>		atomic_int_least16_t;

/// atomic_uint_least16_t
typedef atomic<uint_least16_t>	atomic_uint_least16_t;

/// atomic_int_least32_t
typedef atomic<int_least32_t>		atomic_int_least32_t;

/// atomic_uint_least32_t
typedef atomic<uint_least32_t>	atomic_uint_least32_t;

/// atomic_int_least64_t
typedef atomic<int_least64_t>		atomic_int_least64_t;

/// atomic_uint_least64_t
typedef atomic<uint_least64_t>	atomic_uint_least64_t;


/// atomic_int_fast8_t
typedef atomic<int_fast8_t>		atomic_int_fast8_t;

/// atomic_uint_fast8_t
typedef atomic<uint_fast8_t>		atomic_uint_fast8_t;

/// atomic_int_fast16_t
typedef atomic<int_fast16_t>		atomic_int_fast16_t;

/// atomic_uint_fast16_t
typedef atomic<uint_fast16_t>		atomic_uint_fast16_t;

/// atomic_int_fast32_t
typedef atomic<int_fast32_t>		atomic_int_fast32_t;

/// atomic_uint_fast32_t
typedef atomic<uint_fast32_t>		atomic_uint_fast32_t;

/// atomic_int_fast64_t
typedef atomic<int_fast64_t>		atomic_int_fast64_t;

/// atomic_uint_fast64_t
typedef atomic<uint_fast64_t>		atomic_uint_fast64_t;


/// atomic_intptr_t
typedef atomic<intptr_t>		atomic_intptr_t;

/// atomic_uintptr_t
typedef atomic<uintptr_t>		atomic_uintptr_t;

/// atomic_size_t
typedef atomic<size_t>		atomic_size_t;

/// atomic_intmax_t
typedef atomic<intmax_t>		atomic_intmax_t;

/// atomic_uintmax_t
typedef atomic<uintmax_t>		atomic_uintmax_t;

/// atomic_ptrdiff_t
typedef atomic<ptrdiff_t>		atomic_ptrdiff_t;


// Function definitions, atomic_flag operations.
inline bool
atomic_flag_test_and_set_explicit(atomic_flag* __a,
		    memory_order __m) noexcept
{ return __a->test_and_set(__m); }

inline bool
atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
		    memory_order __m) noexcept
{ return __a->test_and_set(__m); }

inline void
atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
{ __a->clear(__m); }

inline void
atomic_flag_clear_explicit(volatile atomic_flag* __a,
	     memory_order __m) noexcept
{ __a->clear(__m); }

inline bool
atomic_flag_test_and_set(atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

inline bool
atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

inline void
atomic_flag_clear(atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }

inline void
atomic_flag_clear(volatile atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }


// Function templates generally applicable to atomic types.
template<typename _ITp>
  inline bool
  atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
  { return __a->is_lock_free(); }

template<typename _ITp>
  inline bool
  atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
  { return __a->is_lock_free(); }

template<typename _ITp>
  inline void
  atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
  { __a->store(__i, memory_order_relaxed); }

template<typename _ITp>
  inline void
  atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
  { __a->store(__i, memory_order_relaxed); }

template<typename _ITp>
  inline void
  atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
	  memory_order __m) noexcept
  { __a->store(__i, __m); }

template<typename _ITp>
  inline void
  atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
	  memory_order __m) noexcept
  { __a->store(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
  { return __a->load(__m); }

template<typename _ITp>
  inline _ITp
  atomic_load_explicit(const volatile atomic<_ITp>* __a,
	 memory_order __m) noexcept
  { return __a->load(__m); }

template<typename _ITp>
  inline _ITp
  atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
	     memory_order __m) noexcept
  { return __a->exchange(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
	     memory_order __m) noexcept
  { return __a->exchange(__i, __m); }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
			  _ITp* __i1, _ITp __i2,
			  memory_order __m1,
			  memory_order __m2) noexcept
  { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
			  _ITp* __i1, _ITp __i2,
			  memory_order __m1,
			  memory_order __m2) noexcept
  { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
			    _ITp* __i1, _ITp __i2,
			    memory_order __m1,
			    memory_order __m2) noexcept
  { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
			    _ITp* __i1, _ITp __i2,
			    memory_order __m1,
			    memory_order __m2) noexcept
  { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }


template<typename _ITp>
  inline void
  atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
  { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline void
  atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
  { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_load(const atomic<_ITp>* __a) noexcept
  { return atomic_load_explicit(__a, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_load(const volatile atomic<_ITp>* __a) noexcept
  { return atomic_load_explicit(__a, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
  { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
  { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_weak(atomic<_ITp>* __a,
		 _ITp* __i1, _ITp __i2) noexcept
  {
    return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
				   memory_order_seq_cst,
				   memory_order_seq_cst);
  }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
		 _ITp* __i1, _ITp __i2) noexcept
  {
    return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
				   memory_order_seq_cst,
				   memory_order_seq_cst);
  }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_strong(atomic<_ITp>* __a,
		   _ITp* __i1, _ITp __i2) noexcept
  {
    return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
				     memory_order_seq_cst,
				     memory_order_seq_cst);
  }

template<typename _ITp>
  inline bool
  atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
		   _ITp* __i1, _ITp __i2) noexcept
  {
    return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
				     memory_order_seq_cst,
				     memory_order_seq_cst);
  }

// Function templates for atomic_integral operations only, using
// __atomic_base. Template argument should be constricted to
// intergral types as specified in the standard, excluding address
// types.
template<typename _ITp>
  inline _ITp
  atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_add(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_add(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_sub(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_sub(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_and(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_and(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
	     memory_order __m) noexcept
  { return __a->fetch_or(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
	     memory_order __m) noexcept
  { return __a->fetch_or(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_xor(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
	      memory_order __m) noexcept
  { return __a->fetch_xor(__i, __m); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }

template<typename _ITp>
  inline _ITp
  atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
  { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }


// Partial specializations for pointers.
template<typename _ITp>
  inline _ITp*
  atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
	      memory_order __m) noexcept
  { return __a->fetch_add(__d, __m); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
	      memory_order __m) noexcept
  { return __a->fetch_add(__d, __m); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
  { return __a->fetch_add(__d); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
  { return __a->fetch_add(__d); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
	      ptrdiff_t __d, memory_order __m) noexcept
  { return __a->fetch_sub(__d, __m); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
	      memory_order __m) noexcept
  { return __a->fetch_sub(__d, __m); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
  { return __a->fetch_sub(__d); }

template<typename _ITp>
  inline _ITp*
  atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
  { return __a->fetch_sub(__d); }
// @} group atomics

1367_GLIBCXX_END_NAMESPACE_VERSION
1368} // namespace

1370#endif // C++11

1372#endif // _GLIBCXX_ATOMIC

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/atomic_base.h

→

1// -*- C++ -*- header.

3// Copyright (C) 2008-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/atomic_base.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{atomic}
*/

30#ifndef _GLIBCXX_ATOMIC_BASE_H1
31#define _GLIBCXX_ATOMIC_BASE_H1 1

33#pragma GCC system_header

35#include <bits/c++config.h>
36#include <stdint.h>
37#include <bits/atomic_lockfree_defines.h>

39#ifndef _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__))
40#define _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) inline __attribute__((__always_inline__))
41#endif

43namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
44{
45_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @defgroup atomics Atomics
 *
 * Components for performing atomic operations.
 * @{
 */

/// Enumeration for memory_order
typedef enum memory_order
  {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
  } memory_order;

enum __memory_order_modifier
  {
    __memory_order_mask          = 0x0ffff,
    __memory_order_modifier_mask = 0xffff0000,
    __memory_order_hle_acquire   = 0x10000,
    __memory_order_hle_release   = 0x20000
  };

constexpr memory_order
operator|(memory_order __m, __memory_order_modifier __mod)
{
  return memory_order(__m | int(__mod));
}

constexpr memory_order
operator&(memory_order __m, __memory_order_modifier __mod)
{
  return memory_order(__m & int(__mod));
}

// Drop release ordering as per [atomics.types.operations.req]/21
constexpr memory_order
__cmpexch_failure_order2(memory_order __m) noexcept
{
  return __m == memory_order_acq_rel ? memory_order_acquire
    : __m == memory_order_release ? memory_order_relaxed : __m;
}

constexpr memory_order
__cmpexch_failure_order(memory_order __m) noexcept
{
  return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
    | (__m & __memory_order_modifier_mask));
}

_GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
atomic_thread_fence(memory_order __m) noexcept
{ __atomic_thread_fence(__m); }

_GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
atomic_signal_fence(memory_order __m) noexcept
{ __atomic_signal_fence(__m); }

/// kill_dependency
template<typename _Tp>
  inline _Tp
  kill_dependency(_Tp __y) noexcept
  {
    _Tp __ret(__y);
    return __ret;
  }


// Base types for atomics.
template<typename _IntTp>
  struct __atomic_base;


123#define ATOMIC_VAR_INIT(_VI){ _VI } { _VI }

template<typename _Tp>
  struct atomic;

template<typename _Tp>
  struct atomic<_Tp*>;

  /* The target's "set" value for test-and-set may not be exactly 1.  */
132#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL1 == 1
  typedef bool __atomic_flag_data_type;
134#else
  typedef unsigned char __atomic_flag_data_type;
136#endif

/**
 *  @brief Base type for atomic_flag.
 *
 *  Base type is POD with data, allowing atomic_flag to derive from
 *  it and meet the standard layout type requirement. In addition to
 *  compatibility with a C interface, this allows different
 *  implementations of atomic_flag to use the same atomic operation
 *  functions, via a standard conversion to the __atomic_flag_base
 *  argument.
*/
_GLIBCXX_BEGIN_EXTERN_Cextern "C" {

struct __atomic_flag_base
{
  __atomic_flag_data_type _M_i;
};

_GLIBCXX_END_EXTERN_C}

157#define ATOMIC_FLAG_INIT{ 0 } { 0 }

/// atomic_flag
struct atomic_flag : public __atomic_flag_base
{
  atomic_flag() noexcept = default;
  ~atomic_flag() noexcept = default;
  atomic_flag(const atomic_flag&) = delete;
  atomic_flag& operator=(const atomic_flag&) = delete;
  atomic_flag& operator=(const atomic_flag&) volatile = delete;

  // Conversion to ATOMIC_FLAG_INIT.
  constexpr atomic_flag(bool __i) noexcept
    : __atomic_flag_base{ _S_init(__i) }
  { }

  _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
  test_and_set(memory_order __m = memory_order_seq_cst) noexcept
  {
    return __atomic_test_and_set (&_M_i, __m);
  }

  _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
  test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
  {
    return __atomic_test_and_set (&_M_i, __m);
  }

  _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
  clear(memory_order __m = memory_order_seq_cst) noexcept
  {
    memory_order __b = __m & __memory_order_mask;
    __glibcxx_assert(__b != memory_order_consume);
    __glibcxx_assert(__b != memory_order_acquire);
    __glibcxx_assert(__b != memory_order_acq_rel);

    __atomic_clear (&_M_i, __m);
  }

  _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
  clear(memory_order __m = memory_order_seq_cst) volatile noexcept
  {
    memory_order __b = __m & __memory_order_mask;
    __glibcxx_assert(__b != memory_order_consume);
    __glibcxx_assert(__b != memory_order_acquire);
    __glibcxx_assert(__b != memory_order_acq_rel);

    __atomic_clear (&_M_i, __m);
  }

private:
  static constexpr __atomic_flag_data_type
  _S_init(bool __i)
  { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL1 : 0; }
};


/// Base class for atomic integrals.
//
// For each of the integral types, define atomic_[integral type] struct
//
// atomic_bool     bool
// atomic_char     char
// atomic_schar    signed char
// atomic_uchar    unsigned char
// atomic_short    short
// atomic_ushort   unsigned short
// atomic_int      int
// atomic_uint     unsigned int
// atomic_long     long
// atomic_ulong    unsigned long
// atomic_llong    long long
// atomic_ullong   unsigned long long
// atomic_char16_t char16_t
// atomic_char32_t char32_t
// atomic_wchar_t  wchar_t
//
// NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or
// 8 bytes, since that is what GCC built-in functions for atomic
// memory access expect.
template<typename _ITp>
  struct __atomic_base
  {
  private:
    typedef _ITp 	__int_type;

    static constexpr int _S_alignment =
sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);

    alignas(_S_alignment) __int_type _M_i;

  public:
    __atomic_base() noexcept = default;
    ~__atomic_base() noexcept = default;
    __atomic_base(const __atomic_base&) = delete;
    __atomic_base& operator=(const __atomic_base&) = delete;
    __atomic_base& operator=(const __atomic_base&) volatile = delete;

    // Requires __int_type convertible to _M_i.
    constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }

    operator __int_type() const noexcept
    { return load(); }

    operator __int_type() const volatile noexcept
    { return load(); }

    __int_type
    operator=(__int_type __i) noexcept
    {
store(__i);
return __i;
    }

    __int_type
    operator=(__int_type __i) volatile noexcept
    {
store(__i);
return __i;
    }

    __int_type
    operator++(int) noexcept
    { return fetch_add(1); }

    __int_type
    operator++(int) volatile noexcept
    { return fetch_add(1); }

    __int_type
    operator--(int) noexcept
    { return fetch_sub(1); }

    __int_type
    operator--(int) volatile noexcept
    { return fetch_sub(1); }

    __int_type
    operator++() noexcept
    { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }

    __int_type
    operator++() volatile noexcept
    { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }

    __int_type
    operator--() noexcept
    { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }

    __int_type
    operator--() volatile noexcept
    { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }

    __int_type
    operator+=(__int_type __i) noexcept
    { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator+=(__int_type __i) volatile noexcept
    { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator-=(__int_type __i) noexcept
    { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator-=(__int_type __i) volatile noexcept
    { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator&=(__int_type __i) noexcept
    { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator&=(__int_type __i) volatile noexcept
    { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator|=(__int_type __i) noexcept
    { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator|=(__int_type __i) volatile noexcept
    { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator^=(__int_type __i) noexcept
    { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }

    __int_type
    operator^=(__int_type __i) volatile noexcept
    { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }

    bool
    is_lock_free() const noexcept
    {
// Use a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_i),
   reinterpret_cast<void *>(-__alignof(_M_i)));
    }

    bool
    is_lock_free() const volatile noexcept
    {
// Use a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_i),
   reinterpret_cast<void *>(-__alignof(_M_i)));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
    store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_acquire);
__glibcxx_assert(__b != memory_order_acq_rel);
__glibcxx_assert(__b != memory_order_consume);

__atomic_store_n(&_M_i, __i, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
    store(__int_type __i,
   memory_order __m = memory_order_seq_cst) volatile noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_acquire);
__glibcxx_assert(__b != memory_order_acq_rel);
__glibcxx_assert(__b != memory_order_consume);

__atomic_store_n(&_M_i, __i, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    load(memory_order __m = memory_order_seq_cst) const noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_release);
__glibcxx_assert(__b != memory_order_acq_rel);

return __atomic_load_n(&_M_i, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_release);
__glibcxx_assert(__b != memory_order_acq_rel);

return __atomic_load_n(&_M_i, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    exchange(__int_type __i,
      memory_order __m = memory_order_seq_cst) noexcept
    {
return __atomic_exchange_n(&_M_i, __i, __m);
    }


    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    exchange(__int_type __i,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return __atomic_exchange_n(&_M_i, __i, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_weak(__int_type& __i1, __int_type __i2,
	    memory_order __m1, memory_order __m2) noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_weak(__int_type& __i1, __int_type __i2,
	    memory_order __m1,
	    memory_order __m2) volatile noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_weak(__int_type& __i1, __int_type __i2,
	    memory_order __m = memory_order_seq_cst) noexcept
    {
return compare_exchange_weak(__i1, __i2, __m,
		     __cmpexch_failure_order(__m));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_weak(__int_type& __i1, __int_type __i2,
   memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return compare_exchange_weak(__i1, __i2, __m,
		     __cmpexch_failure_order(__m));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__int_type& __i1, __int_type __i2,
	      memory_order __m1, memory_order __m2) noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__int_type& __i1, __int_type __i2,
	      memory_order __m1,
	      memory_order __m2) volatile noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;

__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__int_type& __i1, __int_type __i2,
	      memory_order __m = memory_order_seq_cst) noexcept
    {
return compare_exchange_strong(__i1, __i2, __m,
		       __cmpexch_failure_order(__m));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__int_type& __i1, __int_type __i2,
 memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return compare_exchange_strong(__i1, __i2, __m,
		       __cmpexch_failure_order(__m));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_add(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_add(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_sub(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_sub(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_and(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_and(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_or(__int_type __i,
      memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_or(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_or(__int_type __i,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_or(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_xor(&_M_i, __i, __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __int_type
    fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_xor(&_M_i, __i, __m); }
  };


/// Partial specialization for pointer types.
template<typename _PTp>
  struct __atomic_base<_PTp*>
  {
  private:
    typedef _PTp* 	__pointer_type;

    __pointer_type 	_M_p;

    // Factored out to facilitate explicit specialization.
    constexpr ptrdiff_t
    _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }

    constexpr ptrdiff_t
    _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }

  public:
    __atomic_base() noexcept = default;
    ~__atomic_base() noexcept = default;
    __atomic_base(const __atomic_base&) = delete;
    __atomic_base& operator=(const __atomic_base&) = delete;
    __atomic_base& operator=(const __atomic_base&) volatile = delete;

    // Requires __pointer_type convertible to _M_p.
    constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }

    operator __pointer_type() const noexcept
    { return load(); }

    operator __pointer_type() const volatile noexcept
    { return load(); }

    __pointer_type
    operator=(__pointer_type __p) noexcept
    {
store(__p);
return __p;
    }

    __pointer_type
    operator=(__pointer_type __p) volatile noexcept
    {
store(__p);
return __p;
    }

    __pointer_type
    operator++(int) noexcept
    { return fetch_add(1); }

    __pointer_type
    operator++(int) volatile noexcept
    { return fetch_add(1); }

    __pointer_type
    operator--(int) noexcept
    { return fetch_sub(1); }

    __pointer_type
    operator--(int) volatile noexcept
    { return fetch_sub(1); }

    __pointer_type
    operator++() noexcept
    { return __atomic_add_fetch(&_M_p, _M_type_size(1),
		  memory_order_seq_cst); }

    __pointer_type
    operator++() volatile noexcept
    { return __atomic_add_fetch(&_M_p, _M_type_size(1),
		  memory_order_seq_cst); }

    __pointer_type
    operator--() noexcept
    { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
		  memory_order_seq_cst); }

    __pointer_type
    operator--() volatile noexcept
    { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
		  memory_order_seq_cst); }

    __pointer_type
    operator+=(ptrdiff_t __d) noexcept
    { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
		  memory_order_seq_cst); }

    __pointer_type
    operator+=(ptrdiff_t __d) volatile noexcept
    { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
		  memory_order_seq_cst); }

    __pointer_type
    operator-=(ptrdiff_t __d) noexcept
    { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
		  memory_order_seq_cst); }

    __pointer_type
    operator-=(ptrdiff_t __d) volatile noexcept
    { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
		  memory_order_seq_cst); }

    bool
    is_lock_free() const noexcept
    {
// Produce a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_p),
   reinterpret_cast<void *>(-__alignof(_M_p)));
    }

    bool
    is_lock_free() const volatile noexcept
    {
// Produce a fake, minimally aligned pointer.
return __atomic_is_lock_free(sizeof(_M_p),
   reinterpret_cast<void *>(-__alignof(_M_p)));
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
    store(__pointer_type __p,
   memory_order __m = memory_order_seq_cst) noexcept
    {
      memory_order __b = __m & __memory_order_mask;

__glibcxx_assert(__b != memory_order_acquire);
__glibcxx_assert(__b != memory_order_acq_rel);
__glibcxx_assert(__b != memory_order_consume);

__atomic_store_n(&_M_p, __p, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) void
    store(__pointer_type __p,
   memory_order __m = memory_order_seq_cst) volatile noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_acquire);
__glibcxx_assert(__b != memory_order_acq_rel);
__glibcxx_assert(__b != memory_order_consume);

__atomic_store_n(&_M_p, __p, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    load(memory_order __m = memory_order_seq_cst) const noexcept
    {
memory_order __b = __m & __memory_order_mask;
36
←
Calling 'operator&'→
37
←
Returning from 'operator&'→
44
←
Calling 'operator&'→
45
←
Returning from 'operator&'→
__glibcxx_assert(__b != memory_order_release);
__glibcxx_assert(__b != memory_order_acq_rel);

return __atomic_load_n(&_M_p, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    {
memory_order __b = __m & __memory_order_mask;
__glibcxx_assert(__b != memory_order_release);
__glibcxx_assert(__b != memory_order_acq_rel);

return __atomic_load_n(&_M_p, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    exchange(__pointer_type __p,
      memory_order __m = memory_order_seq_cst) noexcept
    {
return __atomic_exchange_n(&_M_p, __p, __m);
    }


    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    exchange(__pointer_type __p,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    {
return __atomic_exchange_n(&_M_p, __p, __m);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
	      memory_order __m1,
	      memory_order __m2) noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) bool
    compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
	      memory_order __m1,
	      memory_order __m2) volatile noexcept
    {
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;

__glibcxx_assert(__b2 != memory_order_release);
__glibcxx_assert(__b2 != memory_order_acq_rel);
__glibcxx_assert(__b2 <= __b1);

return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
    }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
    { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }

    _GLIBCXX_ALWAYS_INLINEinline __attribute__((__always_inline__)) __pointer_type
    fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
    { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
  };

// @} group atomics

793_GLIBCXX_END_NAMESPACE_VERSION
794} // namespace std

796#endif

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h

→

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

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains some templates that are useful if you are working with the
11// STL at all.
12//
13// No library is required when using these functions.
14//
15//===----------------------------------------------------------------------===//
16 
17#ifndef LLVM_ADT_STLEXTRAS_H
18#define LLVM_ADT_STLEXTRAS_H
19 
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38 
39namespace llvm {
40 
41// Only used by compiler if both template types are the same.  Useful when
42// using SFINAE to test for the existence of member functions.
43template <typename T, T> struct SameType;
44 
45namespace detail {
46 
47template <typename RangeT>
48using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
49 
50template <typename RangeT>
51using ValueOfRange = typename std::remove_reference<decltype(
52    *std::begin(std::declval<RangeT &>()))>::type;
53 
54} // end namespace detail
55 
56//===----------------------------------------------------------------------===//
57//     Extra additions to <functional>
58//===----------------------------------------------------------------------===//
59 
60template <class Ty> struct identity {
61  using argument_type = Ty;
62 
63  Ty &operator()(Ty &self) const {
64    return self;
65  }
66  const Ty &operator()(const Ty &self) const {
67    return self;
68  }
69};
70 
71template <class Ty> struct less_ptr {
72  bool operator()(const Ty* left, const Ty* right) const {
73    return *left < *right;
74  }
75};
76 
77template <class Ty> struct greater_ptr {
78  bool operator()(const Ty* left, const Ty* right) const {
79    return *right < *left;
80  }
81};
82 
83/// An efficient, type-erasing, non-owning reference to a callable. This is
84/// intended for use as the type of a function parameter that is not used
85/// after the function in question returns.
86///
87/// This class does not own the callable, so it is not in general safe to store
88/// a function_ref.
89template<typename Fn> class function_ref;
90 
91template<typename Ret, typename ...Params>
92class function_ref<Ret(Params...)> {
93  Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
94  intptr_t callable;
95 
96  template<typename Callable>
97  static Ret callback_fn(intptr_t callable, Params ...params) {
98    return (*reinterpret_cast<Callable*>(callable))(
99        std::forward<Params>(params)...);
100  }
101 
102public:
103  function_ref() = default;
104  function_ref(std::nullptr_t) {}
105 
106  template <typename Callable>
107  function_ref(Callable &&callable,
108               typename std::enable_if<
109                   !std::is_same<typename std::remove_reference<Callable>::type,
110                                 function_ref>::value>::type * = nullptr)
111      : callback(callback_fn<typename std::remove_reference<Callable>::type>),
112        callable(reinterpret_cast<intptr_t>(&callable)) {}
113 
114  Ret operator()(Params ...params) const {
115    return callback(callable, std::forward<Params>(params)...);
116  }
117 
118  operator bool() const { return callback; }
119};
120 
121// deleter - Very very very simple method that is used to invoke operator
122// delete on something.  It is used like this:
123//
124//   for_each(V.begin(), B.end(), deleter<Interval>);
125template <class T>
126inline void deleter(T *Ptr) {
127  delete Ptr;
128}
129 
130//===----------------------------------------------------------------------===//
131//     Extra additions to <iterator>
132//===----------------------------------------------------------------------===//
133 
134namespace adl_detail {
135 
136using std::begin;
137 
138template <typename ContainerTy>
139auto adl_begin(ContainerTy &&container)
140    -> decltype(begin(std::forward<ContainerTy>(container))) {
141  return begin(std::forward<ContainerTy>(container));
142}
143 
144using std::end;
145 
146template <typename ContainerTy>
147auto adl_end(ContainerTy &&container)
148    -> decltype(end(std::forward<ContainerTy>(container))) {
149  return end(std::forward<ContainerTy>(container));
150}
151 
152using std::swap;
153 
154template <typename T>
155void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
156                                                       std::declval<T>()))) {
157  swap(std::forward<T>(lhs), std::forward<T>(rhs));
158}
159 
160} // end namespace adl_detail
161 
162template <typename ContainerTy>
163auto adl_begin(ContainerTy &&container)
164    -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
165  return adl_detail::adl_begin(std::forward<ContainerTy>(container));
166}
167 
168template <typename ContainerTy>
169auto adl_end(ContainerTy &&container)
170    -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
171  return adl_detail::adl_end(std::forward<ContainerTy>(container));
172}
173 
174template <typename T>
175void adl_swap(T &&lhs, T &&rhs) noexcept(
176    noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
177  adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
178}
179 
180// mapped_iterator - This is a simple iterator adapter that causes a function to
181// be applied whenever operator* is invoked on the iterator.
182 
183template <typename ItTy, typename FuncTy,
184          typename FuncReturnTy =
185            decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
186class mapped_iterator
187    : public iterator_adaptor_base<
188             mapped_iterator<ItTy, FuncTy>, ItTy,
189             typename std::iterator_traits<ItTy>::iterator_category,
190             typename std::remove_reference<FuncReturnTy>::type> {
191public:
192  mapped_iterator(ItTy U, FuncTy F)
193    : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
194 
195  ItTy getCurrent() { return this->I; }
196 
197  FuncReturnTy operator*() { return F(*this->I); }
198 
199private:
200  FuncTy F;
201};
202 
203// map_iterator - Provide a convenient way to create mapped_iterators, just like
204// make_pair is useful for creating pairs...
205template <class ItTy, class FuncTy>
206inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
207  return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
208}
209 
210/// Helper to determine if type T has a member called rbegin().
211template <typename Ty> class has_rbegin_impl {
212  using yes = char[1];
213  using no = char[2];
214 
215  template <typename Inner>
216  static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
217 
218  template <typename>
219  static no& test(...);
220 
221public:
222  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
223};
224 
225/// Metafunction to determine if T& or T has a member called rbegin().
226template <typename Ty>
227struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
228};
229 
230// Returns an iterator_range over the given container which iterates in reverse.
231// Note that the container must have rbegin()/rend() methods for this to work.
232template <typename ContainerTy>
233auto reverse(ContainerTy &&C,
234             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
235                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
236  return make_range(C.rbegin(), C.rend());
237}
238 
239// Returns a std::reverse_iterator wrapped around the given iterator.
240template <typename IteratorTy>
241std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
242  return std::reverse_iterator<IteratorTy>(It);
243}
244 
245// Returns an iterator_range over the given container which iterates in reverse.
246// Note that the container must have begin()/end() methods which return
247// bidirectional iterators for this to work.
248template <typename ContainerTy>
249auto reverse(
250    ContainerTy &&C,
251    typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
252    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
253                           llvm::make_reverse_iterator(std::begin(C)))) {
254  return make_range(llvm::make_reverse_iterator(std::end(C)),
255                    llvm::make_reverse_iterator(std::begin(C)));
256}
257 
258/// An iterator adaptor that filters the elements of given inner iterators.
259///
260/// The predicate parameter should be a callable object that accepts the wrapped
261/// iterator's reference type and returns a bool. When incrementing or
262/// decrementing the iterator, it will call the predicate on each element and
263/// skip any where it returns false.
264///
265/// \code
266///   int A[] = { 1, 2, 3, 4 };
267///   auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
268///   // R contains { 1, 3 }.
269/// \endcode
270template <typename WrappedIteratorT, typename PredicateT>
271class filter_iterator
272    : public iterator_adaptor_base<
273          filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
274          typename std::common_type<
275              std::forward_iterator_tag,
276              typename std::iterator_traits<
277                  WrappedIteratorT>::iterator_category>::type> {
278  using BaseT = iterator_adaptor_base<
279      filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
280      typename std::common_type<
281          std::forward_iterator_tag,
282          typename std::iterator_traits<WrappedIteratorT>::iterator_category>::
283          type>;
284 
285  struct PayloadType {
286    WrappedIteratorT End;
287    PredicateT Pred;
288  };
289 
290  Optional<PayloadType> Payload;
291 
292  void findNextValid() {
293    assert(Payload && "Payload should be engaged when findNextValid is called")(static_cast <bool> (Payload && "Payload should be engaged when findNextValid is called"
) ? void (0) : __assert_fail ("Payload && \"Payload should be engaged when findNextValid is called\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 293, __extension__ __PRETTY_FUNCTION__));
294    while (this->I != Payload->End && !Payload->Pred(*this->I))
295      BaseT::operator++();
296  }
297 
298  // Construct the begin iterator. The begin iterator requires to know where end
299  // is, so that it can properly stop when it hits end.
300  filter_iterator(WrappedIteratorT Begin, WrappedIteratorT End, PredicateT Pred)
301      : BaseT(std::move(Begin)),
302        Payload(PayloadType{std::move(End), std::move(Pred)}) {
303    findNextValid();
304  }
305 
306  // Construct the end iterator. It's not incrementable, so Payload doesn't
307  // have to be engaged.
308  filter_iterator(WrappedIteratorT End) : BaseT(End) {}
309 
310public:
311  using BaseT::operator++;
312 
313  filter_iterator &operator++() {
314    BaseT::operator++();
315    findNextValid();
316    return *this;
317  }
318 
319  template <typename RT, typename PT>
320  friend iterator_range<filter_iterator<detail::IterOfRange<RT>, PT>>
321  make_filter_range(RT &&, PT);
322};
323 
324/// Convenience function that takes a range of elements and a predicate,
325/// and return a new filter_iterator range.
326///
327/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
328/// lifetime of that temporary is not kept by the returned range object, and the
329/// temporary is going to be dropped on the floor after the make_iterator_range
330/// full expression that contains this function call.
331template <typename RangeT, typename PredicateT>
332iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
333make_filter_range(RangeT &&Range, PredicateT Pred) {
334  using FilterIteratorT =
335      filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
336  return make_range(FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
337                                    std::end(std::forward<RangeT>(Range)),
338                                    std::move(Pred)),
339                    FilterIteratorT(std::end(std::forward<RangeT>(Range))));
340}
341 
342// forward declarations required by zip_shortest/zip_first
343template <typename R, typename UnaryPredicate>
344bool all_of(R &&range, UnaryPredicate P);
345 
346template <size_t... I> struct index_sequence;
347 
348template <class... Ts> struct index_sequence_for;
349 
350namespace detail {
351 
352using std::declval;
353 
354// We have to alias this since inlining the actual type at the usage site
355// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
356template<typename... Iters> struct ZipTupleType {
357  using type = std::tuple<decltype(*declval<Iters>())...>;
358};
359 
360template <typename ZipType, typename... Iters>
361using zip_traits = iterator_facade_base<
362    ZipType, typename std::common_type<std::bidirectional_iterator_tag,
363                                       typename std::iterator_traits<
364                                           Iters>::iterator_category...>::type,
365    // ^ TODO: Implement random access methods.
366    typename ZipTupleType<Iters...>::type,
367    typename std::iterator_traits<typename std::tuple_element<
368        0, std::tuple<Iters...>>::type>::difference_type,
369    // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
370    // inner iterators have the same difference_type. It would fail if, for
371    // instance, the second field's difference_type were non-numeric while the
372    // first is.
373    typename ZipTupleType<Iters...>::type *,
374    typename ZipTupleType<Iters...>::type>;
375 
376template <typename ZipType, typename... Iters>
377struct zip_common : public zip_traits<ZipType, Iters...> {
378  using Base = zip_traits<ZipType, Iters...>;
379  using value_type = typename Base::value_type;
380 
381  std::tuple<Iters...> iterators;
382 
383protected:
384  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
385    return value_type(*std::get<Ns>(iterators)...);
386  }
387 
388  template <size_t... Ns>
389  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
390    return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
391  }
392 
393  template <size_t... Ns>
394  decltype(iterators) tup_dec(index_sequence<Ns...>) const {
395    return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
396  }
397 
398public:
399  zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
400 
401  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
402 
403  const value_type operator*() const {
404    return deref(index_sequence_for<Iters...>{});
405  }
406 
407  ZipType &operator++() {
408    iterators = tup_inc(index_sequence_for<Iters...>{});
409    return *reinterpret_cast<ZipType *>(this);
410  }
411 
412  ZipType &operator--() {
413    static_assert(Base::IsBidirectional,
414                  "All inner iterators must be at least bidirectional.");
415    iterators = tup_dec(index_sequence_for<Iters...>{});
416    return *reinterpret_cast<ZipType *>(this);
417  }
418};
419 
420template <typename... Iters>
421struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
422  using Base = zip_common<zip_first<Iters...>, Iters...>;
423 
424  bool operator==(const zip_first<Iters...> &other) const {
425    return std::get<0>(this->iterators) == std::get<0>(other.iterators);
426  }
427 
428  zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
429};
430 
431template <typename... Iters>
432class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
433  template <size_t... Ns>
434  bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
435    return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
436                                              std::get<Ns>(other.iterators)...},
437                  identity<bool>{});
438  }
439 
440public:
441  using Base = zip_common<zip_shortest<Iters...>, Iters...>;
442 
443  zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
444 
445  bool operator==(const zip_shortest<Iters...> &other) const {
446    return !test(other, index_sequence_for<Iters...>{});
447  }
448};
449 
450template <template <typename...> class ItType, typename... Args> class zippy {
451public:
452  using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
453  using iterator_category = typename iterator::iterator_category;
454  using value_type = typename iterator::value_type;
455  using difference_type = typename iterator::difference_type;
456  using pointer = typename iterator::pointer;
457  using reference = typename iterator::reference;
458 
459private:
460  std::tuple<Args...> ts;
461 
462  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
463    return iterator(std::begin(std::get<Ns>(ts))...);
464  }
465  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
466    return iterator(std::end(std::get<Ns>(ts))...);
467  }
468 
469public:
470  zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
471 
472  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
473  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
474};
475 
476} // end namespace detail
477 
478/// zip iterator for two or more iteratable types.
479template <typename T, typename U, typename... Args>
480detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
481                                                       Args &&... args) {
482  return detail::zippy<detail::zip_shortest, T, U, Args...>(
483      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
484}
485 
486/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
487/// be the shortest.
488template <typename T, typename U, typename... Args>
489detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
490                                                          Args &&... args) {
491  return detail::zippy<detail::zip_first, T, U, Args...>(
492      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
493}
494 
495/// Iterator wrapper that concatenates sequences together.
496///
497/// This can concatenate different iterators, even with different types, into
498/// a single iterator provided the value types of all the concatenated
499/// iterators expose `reference` and `pointer` types that can be converted to
500/// `ValueT &` and `ValueT *` respectively. It doesn't support more
501/// interesting/customized pointer or reference types.
502///
503/// Currently this only supports forward or higher iterator categories as
504/// inputs and always exposes a forward iterator interface.
505template <typename ValueT, typename... IterTs>
506class concat_iterator
507    : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
508                                  std::forward_iterator_tag, ValueT> {
509  using BaseT = typename concat_iterator::iterator_facade_base;
510 
511  /// We store both the current and end iterators for each concatenated
512  /// sequence in a tuple of pairs.
513  ///
514  /// Note that something like iterator_range seems nice at first here, but the
515  /// range properties are of little benefit and end up getting in the way
516  /// because we need to do mutation on the current iterators.
517  std::tuple<std::pair<IterTs, IterTs>...> IterPairs;
518 
519  /// Attempts to increment a specific iterator.
520  ///
521  /// Returns true if it was able to increment the iterator. Returns false if
522  /// the iterator is already at the end iterator.
523  template <size_t Index> bool incrementHelper() {
524    auto &IterPair = std::get<Index>(IterPairs);
525    if (IterPair.first == IterPair.second)
526      return false;
527 
528    ++IterPair.first;
529    return true;
530  }
531 
532  /// Increments the first non-end iterator.
533  ///
534  /// It is an error to call this with all iterators at the end.
535  template <size_t... Ns> void increment(index_sequence<Ns...>) {
536    // Build a sequence of functions to increment each iterator if possible.
537    bool (concat_iterator::*IncrementHelperFns[])() = {
538        &concat_iterator::incrementHelper<Ns>...};
539 
540    // Loop over them, and stop as soon as we succeed at incrementing one.
541    for (auto &IncrementHelperFn : IncrementHelperFns)
542      if ((this->*IncrementHelperFn)())
543        return;
544 
545    llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 545);
546  }
547 
548  /// Returns null if the specified iterator is at the end. Otherwise,
549  /// dereferences the iterator and returns the address of the resulting
550  /// reference.
551  template <size_t Index> ValueT *getHelper() const {
552    auto &IterPair = std::get<Index>(IterPairs);
553    if (IterPair.first == IterPair.second)
554      return nullptr;
555 
556    return &*IterPair.first;
557  }
558 
559  /// Finds the first non-end iterator, dereferences, and returns the resulting
560  /// reference.
561  ///
562  /// It is an error to call this with all iterators at the end.
563  template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
564    // Build a sequence of functions to get from iterator if possible.
565    ValueT *(concat_iterator::*GetHelperFns[])() const = {
566        &concat_iterator::getHelper<Ns>...};
567 
568    // Loop over them, and return the first result we find.
569    for (auto &GetHelperFn : GetHelperFns)
570      if (ValueT *P = (this->*GetHelperFn)())
571        return *P;
572 
573    llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 573);
574  }
575 
576public:
577  /// Constructs an iterator from a squence of ranges.
578  ///
579  /// We need the full range to know how to switch between each of the
580  /// iterators.
581  template <typename... RangeTs>
582  explicit concat_iterator(RangeTs &&... Ranges)
583      : IterPairs({std::begin(Ranges), std::end(Ranges)}...) {}
584 
585  using BaseT::operator++;
586 
587  concat_iterator &operator++() {
588    increment(index_sequence_for<IterTs...>());
589    return *this;
590  }
591 
592  ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
593 
594  bool operator==(const concat_iterator &RHS) const {
595    return IterPairs == RHS.IterPairs;
596  }
597};
598 
599namespace detail {
600 
601/// Helper to store a sequence of ranges being concatenated and access them.
602///
603/// This is designed to facilitate providing actual storage when temporaries
604/// are passed into the constructor such that we can use it as part of range
605/// based for loops.
606template <typename ValueT, typename... RangeTs> class concat_range {
607public:
608  using iterator =
609      concat_iterator<ValueT,
610                      decltype(std::begin(std::declval<RangeTs &>()))...>;
611 
612private:
613  std::tuple<RangeTs...> Ranges;
614 
615  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
616    return iterator(std::get<Ns>(Ranges)...);
617  }
618  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
619    return iterator(make_range(std::end(std::get<Ns>(Ranges)),
620                               std::end(std::get<Ns>(Ranges)))...);
621  }
622 
623public:
624  concat_range(RangeTs &&... Ranges)
625      : Ranges(std::forward<RangeTs>(Ranges)...) {}
626 
627  iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
628  iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
629};
630 
631} // end namespace detail
632 
633/// Concatenated range across two or more ranges.
634///
635/// The desired value type must be explicitly specified.
636template <typename ValueT, typename... RangeTs>
637detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
638  static_assert(sizeof...(RangeTs) > 1,
639                "Need more than one range to concatenate!");
640  return detail::concat_range<ValueT, RangeTs...>(
641      std::forward<RangeTs>(Ranges)...);
642}
643 
644//===----------------------------------------------------------------------===//
645//     Extra additions to <utility>
646//===----------------------------------------------------------------------===//
647 
648/// \brief Function object to check whether the first component of a std::pair
649/// compares less than the first component of another std::pair.
650struct less_first {
651  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
652    return lhs.first < rhs.first;
653  }
654};
655 
656/// \brief Function object to check whether the second component of a std::pair
657/// compares less than the second component of another std::pair.
658struct less_second {
659  template <typename T> bool operator()(const T &lhs, const T &rhs) const {
660    return lhs.second < rhs.second;
661  }
662};
663 
664// A subset of N3658. More stuff can be added as-needed.
665 
666/// \brief Represents a compile-time sequence of integers.
667template <class T, T... I> struct integer_sequence {
668  using value_type = T;
669 
670  static constexpr size_t size() { return sizeof...(I); }
671};
672 
673/// \brief Alias for the common case of a sequence of size_ts.
674template <size_t... I>
675struct index_sequence : integer_sequence<std::size_t, I...> {};
676 
677template <std::size_t N, std::size_t... I>
678struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
679template <std::size_t... I>
680struct build_index_impl<0, I...> : index_sequence<I...> {};
681 
682/// \brief Creates a compile-time integer sequence for a parameter pack.
683template <class... Ts>
684struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
685 
686/// Utility type to build an inheritance chain that makes it easy to rank
687/// overload candidates.
688template <int N> struct rank : rank<N - 1> {};
689template <> struct rank<0> {};
690 
691/// \brief traits class for checking whether type T is one of any of the given
692/// types in the variadic list.
693template <typename T, typename... Ts> struct is_one_of {
694  static const bool value = false;
695};
696 
697template <typename T, typename U, typename... Ts>
698struct is_one_of<T, U, Ts...> {
699  static const bool value =
700      std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
701};
702 
703/// \brief traits class for checking whether type T is a base class for all
704///  the given types in the variadic list.
705template <typename T, typename... Ts> struct are_base_of {
706  static const bool value = true;
707};
708 
709template <typename T, typename U, typename... Ts>
710struct are_base_of<T, U, Ts...> {
711  static const bool value =
712      std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
713};
714 
715//===----------------------------------------------------------------------===//
716//     Extra additions for arrays
717//===----------------------------------------------------------------------===//
718 
719/// Find the length of an array.
720template <class T, std::size_t N>
721constexpr inline size_t array_lengthof(T (&)[N]) {
722  return N;
723}
724 
725/// Adapt std::less<T> for array_pod_sort.
726template<typename T>
727inline int array_pod_sort_comparator(const void *P1, const void *P2) {
728  if (std::less<T>()(*reinterpret_cast<const T*>(P1),
729                     *reinterpret_cast<const T*>(P2)))
730    return -1;
731  if (std::less<T>()(*reinterpret_cast<const T*>(P2),
732                     *reinterpret_cast<const T*>(P1)))
733    return 1;
734  return 0;
735}
736 
737/// get_array_pod_sort_comparator - This is an internal helper function used to
738/// get type deduction of T right.
739template<typename T>
740inline int (*get_array_pod_sort_comparator(const T &))
741             (const void*, const void*) {
742  return array_pod_sort_comparator<T>;
743}
744 
745/// array_pod_sort - This sorts an array with the specified start and end
746/// extent.  This is just like std::sort, except that it calls qsort instead of
747/// using an inlined template.  qsort is slightly slower than std::sort, but
748/// most sorts are not performance critical in LLVM and std::sort has to be
749/// template instantiated for each type, leading to significant measured code
750/// bloat.  This function should generally be used instead of std::sort where
751/// possible.
752///
753/// This function assumes that you have simple POD-like types that can be
754/// compared with std::less and can be moved with memcpy.  If this isn't true,
755/// you should use std::sort.
756///
757/// NOTE: If qsort_r were portable, we could allow a custom comparator and
758/// default to std::less.
759template<class IteratorTy>
760inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
761  // Don't inefficiently call qsort with one element or trigger undefined
762  // behavior with an empty sequence.
763  auto NElts = End - Start;
764  if (NElts <= 1) return;
765  qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
766}
767 
768template <class IteratorTy>
769inline void array_pod_sort(
770    IteratorTy Start, IteratorTy End,
771    int (*Compare)(
772        const typename std::iterator_traits<IteratorTy>::value_type *,
773        const typename std::iterator_traits<IteratorTy>::value_type *)) {
774  // Don't inefficiently call qsort with one element or trigger undefined
775  // behavior with an empty sequence.
776  auto NElts = End - Start;
777  if (NElts <= 1) return;
778  qsort(&*Start, NElts, sizeof(*Start),
779        reinterpret_cast<int (*)(const void *, const void *)>(Compare));
780}
781 
782//===----------------------------------------------------------------------===//
783//     Extra additions to <algorithm>
784//===----------------------------------------------------------------------===//
785 
786/// For a container of pointers, deletes the pointers and then clears the
787/// container.
788template<typename Container>
789void DeleteContainerPointers(Container &C) {
790  for (auto V : C)
791    delete V;
792  C.clear();
793}
794 
795/// In a container of pairs (usually a map) whose second element is a pointer,
796/// deletes the second elements and then clears the container.
797template<typename Container>
798void DeleteContainerSeconds(Container &C) {
799  for (auto &V : C)
800    delete V.second;
801  C.clear();
802}
803 
804/// Provide wrappers to std::for_each which take ranges instead of having to
805/// pass begin/end explicitly.
806template <typename R, typename UnaryPredicate>
807UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
808  return std::for_each(adl_begin(Range), adl_end(Range), P);
809}
810 
811/// Provide wrappers to std::all_of which take ranges instead of having to pass
812/// begin/end explicitly.
813template <typename R, typename UnaryPredicate>
814bool all_of(R &&Range, UnaryPredicate P) {
815  return std::all_of(adl_begin(Range), adl_end(Range), P);
816}
817 
818/// Provide wrappers to std::any_of which take ranges instead of having to pass
819/// begin/end explicitly.
820template <typename R, typename UnaryPredicate>
821bool any_of(R &&Range, UnaryPredicate P) {
822  return std::any_of(adl_begin(Range), adl_end(Range), P);
823}
824 
825/// Provide wrappers to std::none_of which take ranges instead of having to pass
826/// begin/end explicitly.
827template <typename R, typename UnaryPredicate>
828bool none_of(R &&Range, UnaryPredicate P) {
829  return std::none_of(adl_begin(Range), adl_end(Range), P);
830}
831 
832/// Provide wrappers to std::find which take ranges instead of having to pass
833/// begin/end explicitly.
834template <typename R, typename T>
835auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
836  return std::find(adl_begin(Range), adl_end(Range), Val);
837}
838 
839/// Provide wrappers to std::find_if which take ranges instead of having to pass
840/// begin/end explicitly.
841template <typename R, typename UnaryPredicate>
842auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
843  return std::find_if(adl_begin(Range), adl_end(Range), P);
844}
845 
846template <typename R, typename UnaryPredicate>
847auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
848  return std::find_if_not(adl_begin(Range), adl_end(Range), P);
849}
850 
851/// Provide wrappers to std::remove_if which take ranges instead of having to
852/// pass begin/end explicitly.
853template <typename R, typename UnaryPredicate>
854auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
855  return std::remove_if(adl_begin(Range), adl_end(Range), P);
856}
857 
858/// Provide wrappers to std::copy_if which take ranges instead of having to
859/// pass begin/end explicitly.
860template <typename R, typename OutputIt, typename UnaryPredicate>
861OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
862  return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
863}
864 
865template <typename R, typename OutputIt>
866OutputIt copy(R &&Range, OutputIt Out) {
867  return std::copy(adl_begin(Range), adl_end(Range), Out);
868}
869 
870/// Wrapper function around std::find to detect if an element exists
871/// in a container.
872template <typename R, typename E>
873bool is_contained(R &&Range, const E &Element) {
874  return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
875}
876 
877/// Wrapper function around std::count to count the number of times an element
878/// \p Element occurs in the given range \p Range.
879template <typename R, typename E>
880auto count(R &&Range, const E &Element) ->
881    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
882  return std::count(adl_begin(Range), adl_end(Range), Element);
883}
884 
885/// Wrapper function around std::count_if to count the number of times an
886/// element satisfying a given predicate occurs in a range.
887template <typename R, typename UnaryPredicate>
888auto count_if(R &&Range, UnaryPredicate P) ->
889    typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
890  return std::count_if(adl_begin(Range), adl_end(Range), P);
891}
892 
893/// Wrapper function around std::transform to apply a function to a range and
894/// store the result elsewhere.
895template <typename R, typename OutputIt, typename UnaryPredicate>
896OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
897  return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
898}
899 
900/// Provide wrappers to std::partition which take ranges instead of having to
901/// pass begin/end explicitly.
902template <typename R, typename UnaryPredicate>
903auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
904  return std::partition(adl_begin(Range), adl_end(Range), P);
905}
906 
907/// Provide wrappers to std::lower_bound which take ranges instead of having to
908/// pass begin/end explicitly.
909template <typename R, typename ForwardIt>
910auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
911  return std::lower_bound(adl_begin(Range), adl_end(Range), I);
912}
913 
914/// \brief Given a range of type R, iterate the entire range and return a
915/// SmallVector with elements of the vector.  This is useful, for example,
916/// when you want to iterate a range and then sort the results.
917template <unsigned Size, typename R>
918SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
919to_vector(R &&Range) {
920  return {adl_begin(Range), adl_end(Range)};
921}
922 
923/// Provide a container algorithm similar to C++ Library Fundamentals v2's
924/// `erase_if` which is equivalent to:
925///
926///   C.erase(remove_if(C, pred), C.end());
927///
928/// This version works for any container with an erase method call accepting
929/// two iterators.
930template <typename Container, typename UnaryPredicate>
931void erase_if(Container &C, UnaryPredicate P) {
932  C.erase(remove_if(C, P), C.end());
933}
934 
935//===----------------------------------------------------------------------===//
936//     Extra additions to <memory>
937//===----------------------------------------------------------------------===//
938 
939// Implement make_unique according to N3656.
940 
941/// \brief Constructs a `new T()` with the given args and returns a
942///        `unique_ptr<T>` which owns the object.
943///
944/// Example:
945///
946///     auto p = make_unique<int>();
947///     auto p = make_unique<std::tuple<int, int>>(0, 1);
948template <class T, class... Args>
949typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
950make_unique(Args &&... args) {
951  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
59
←
Calling 'forward'→
60
←
Returning from 'forward'→
61
←
Calling 'forward'→
62
←
Returning from 'forward'→
952}
953 
954/// \brief Constructs a `new T[n]` with the given args and returns a
955///        `unique_ptr<T[]>` which owns the object.
956///
957/// \param n size of the new array.
958///
959/// Example:
960///
961///     auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
962template <class T>
963typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
964                        std::unique_ptr<T>>::type
965make_unique(size_t n) {
966  return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
967}
968 
969/// This function isn't used and is only here to provide better compile errors.
970template <class T, class... Args>
971typename std::enable_if<std::extent<T>::value != 0>::type
972make_unique(Args &&...) = delete;
973 
974struct FreeDeleter {
975  void operator()(void* v) {
976    ::free(v);
977  }
978};
979 
980template<typename First, typename Second>
981struct pair_hash {
982  size_t operator()(const std::pair<First, Second> &P) const {
983    return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
984  }
985};
986 
987/// A functor like C++14's std::less<void> in its absence.
988struct less {
989  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
990    return std::forward<A>(a) < std::forward<B>(b);
991  }
992};
993 
994/// A functor like C++14's std::equal<void> in its absence.
995struct equal {
996  template <typename A, typename B> bool operator()(A &&a, B &&b) const {
997    return std::forward<A>(a) == std::forward<B>(b);
998  }
999};
1000 
1001/// Binary functor that adapts to any other binary functor after dereferencing
1002/// operands.
1003template <typename T> struct deref {
1004  T func;
1005 
1006  // Could be further improved to cope with non-derivable functors and
1007  // non-binary functors (should be a variadic template member function
1008  // operator()).
1009  template <typename A, typename B>
1010  auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1011    assert(lhs)(static_cast <bool> (lhs) ? void (0) : __assert_fail ("lhs"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 1011, __extension__ __PRETTY_FUNCTION__));
1012    assert(rhs)(static_cast <bool> (rhs) ? void (0) : __assert_fail ("rhs"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 1012, __extension__ __PRETTY_FUNCTION__));
1013    return func(*lhs, *rhs);
1014  }
1015};
1016 
1017namespace detail {
1018 
1019template <typename R> class enumerator_iter;
1020 
1021template <typename R> struct result_pair {
1022  friend class enumerator_iter<R>;
1023 
1024  result_pair() = default;
1025  result_pair(std::size_t Index, IterOfRange<R> Iter)
1026      : Index(Index), Iter(Iter) {}
1027 
1028  result_pair<R> &operator=(const result_pair<R> &Other) {
1029    Index = Other.Index;
1030    Iter = Other.Iter;
1031    return *this;
1032  }
1033 
1034  std::size_t index() const { return Index; }
1035  const ValueOfRange<R> &value() const { return *Iter; }
1036  ValueOfRange<R> &value() { return *Iter; }
1037 
1038private:
1039  std::size_t Index = std::numeric_limits<std::size_t>::max();
1040  IterOfRange<R> Iter;
1041};
1042 
1043template <typename R>
1044class enumerator_iter
1045    : public iterator_facade_base<
1046          enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1047          typename std::iterator_traits<IterOfRange<R>>::difference_type,
1048          typename std::iterator_traits<IterOfRange<R>>::pointer,
1049          typename std::iterator_traits<IterOfRange<R>>::reference> {
1050  using result_type = result_pair<R>;
1051 
1052public:
1053  explicit enumerator_iter(IterOfRange<R> EndIter)
1054      : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1055 
1056  enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1057      : Result(Index, Iter) {}
1058 
1059  result_type &operator*() { return Result; }
1060  const result_type &operator*() const { return Result; }
1061 
1062  enumerator_iter<R> &operator++() {
1063    assert(Result.Index != std::numeric_limits<size_t>::max())(static_cast <bool> (Result.Index != std::numeric_limits
<size_t>::max()) ? void (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/STLExtras.h"
, 1063, __extension__ __PRETTY_FUNCTION__));
1064    ++Result.Iter;
1065    ++Result.Index;
1066    return *this;
1067  }
1068 
1069  bool operator==(const enumerator_iter<R> &RHS) const {
1070    // Don't compare indices here, only iterators.  It's possible for an end
1071    // iterator to have different indices depending on whether it was created
1072    // by calling std::end() versus incrementing a valid iterator.
1073    return Result.Iter == RHS.Result.Iter;
1074  }
1075 
1076  enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1077    Result = Other.Result;
1078    return *this;
1079  }
1080 
1081private:
1082  result_type Result;
1083};
1084 
1085template <typename R> class enumerator {
1086public:
1087  explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1088 
1089  enumerator_iter<R> begin() {
1090    return enumerator_iter<R>(0, std::begin(TheRange));
1091  }
1092 
1093  enumerator_iter<R> end() {
1094    return enumerator_iter<R>(std::end(TheRange));
1095  }
1096 
1097private:
1098  R TheRange;
1099};
1100 
1101} // end namespace detail
1102 
1103/// Given an input range, returns a new range whose values are are pair (A,B)
1104/// such that A is the 0-based index of the item in the sequence, and B is
1105/// the value from the original sequence.  Example:
1106///
1107/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1108/// for (auto X : enumerate(Items)) {
1109///   printf("Item %d - %c\n", X.index(), X.value());
1110/// }
1111///
1112/// Output:
1113///   Item 0 - A
1114///   Item 1 - B
1115///   Item 2 - C
1116///   Item 3 - D
1117///
1118template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1119  return detail::enumerator<R>(std::forward<R>(TheRange));
1120}
1121 
1122namespace detail {
1123 
1124template <typename F, typename Tuple, std::size_t... I>
1125auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1126    -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1127  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1128}
1129 
1130} // end namespace detail
1131 
1132/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1133/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1134/// return the result.
1135template <typename F, typename Tuple>
1136auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1137    std::forward<F>(f), std::forward<Tuple>(t),
1138    build_index_impl<
1139        std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1140  using Indices = build_index_impl<
1141      std::tuple_size<typename std::decay<Tuple>::type>::value>;
1142 
1143  return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1144                                  Indices{});
1145}
1146 
1147} // end namespace llvm
1148 
1149#endif // LLVM_ADT_STLEXTRAS_H