/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp

Bug Summary

File:	llvm/lib/Object/COFFObjectFile.cpp
Warning:	line 1103, column 7 Called C++ object pointer is null

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 COFFObjectFile.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/Object -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.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++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/Object -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp

→

1//===- COFFObjectFile.cpp - COFF object file implementation ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the COFFObjectFile class.
10//
11//===----------------------------------------------------------------------===//

13#include "llvm/ADT/ArrayRef.h"
14#include "llvm/ADT/StringRef.h"
15#include "llvm/ADT/Triple.h"
16#include "llvm/ADT/iterator_range.h"
17#include "llvm/BinaryFormat/COFF.h"
18#include "llvm/Object/Binary.h"
19#include "llvm/Object/COFF.h"
20#include "llvm/Object/Error.h"
21#include "llvm/Object/ObjectFile.h"
22#include "llvm/Support/BinaryStreamReader.h"
23#include "llvm/Support/Endian.h"
24#include "llvm/Support/Error.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/MathExtras.h"
27#include "llvm/Support/MemoryBuffer.h"
28#include <algorithm>
29#include <cassert>
30#include <cstddef>
31#include <cstdint>
32#include <cstring>
33#include <limits>
34#include <memory>
35#include <system_error>

37using namespace llvm;
38using namespace object;

40using support::ulittle16_t;
41using support::ulittle32_t;
42using support::ulittle64_t;
43using support::little16_t;

45// Returns false if size is greater than the buffer size. And sets ec.
46static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size) {
if (M.getBufferSize() < Size) {
  EC = object_error::unexpected_eof;
  return false;
}
return true;
52}

54// Sets Obj unless any bytes in [addr, addr + size) fall outsize of m.
55// Returns unexpected_eof if error.
56template <typename T>
57static std::error_code getObject(const T *&Obj, MemoryBufferRef M,
                               const void *Ptr,
                               const uint64_t Size = sizeof(T)) {
uintptr_t Addr = uintptr_t(Ptr);
if (std::error_code EC = Binary::checkOffset(M, Addr, Size))
  return EC;
Obj = reinterpret_cast<const T *>(Addr);
return std::error_code();
65}

67// Decode a string table entry in base 64 (//AAAAAA). Expects \arg Str without
68// prefixed slashes.
69static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result) {
assert(Str.size() <= 6 && "String too long, possible overflow.")((Str.size() <= 6 && "String too long, possible overflow."
) ? static_cast<void> (0) : __assert_fail ("Str.size() <= 6 && \"String too long, possible overflow.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 70, __PRETTY_FUNCTION__));
if (Str.size() > 6)
  return true;

uint64_t Value = 0;
while (!Str.empty()) {
  unsigned CharVal;
  if (Str[0] >= 'A' && Str[0] <= 'Z') // 0..25
    CharVal = Str[0] - 'A';
  else if (Str[0] >= 'a' && Str[0] <= 'z') // 26..51
    CharVal = Str[0] - 'a' + 26;
  else if (Str[0] >= '0' && Str[0] <= '9') // 52..61
    CharVal = Str[0] - '0' + 52;
  else if (Str[0] == '+') // 62
    CharVal = 62;
  else if (Str[0] == '/') // 63
    CharVal = 63;
  else
    return true;

  Value = (Value * 64) + CharVal;
  Str = Str.substr(1);
}

if (Value > std::numeric_limits<uint32_t>::max())
  return true;

Result = static_cast<uint32_t>(Value);
return false;
99}

101template <typename coff_symbol_type>
102const coff_symbol_type *COFFObjectFile::toSymb(DataRefImpl Ref) const {
const coff_symbol_type *Addr =
    reinterpret_cast<const coff_symbol_type *>(Ref.p);

assert(!checkOffset(Data, uintptr_t(Addr), sizeof(*Addr)))((!checkOffset(Data, uintptr_t(Addr), sizeof(*Addr))) ? static_cast
<void> (0) : __assert_fail ("!checkOffset(Data, uintptr_t(Addr), sizeof(*Addr))"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 106, __PRETTY_FUNCTION__));
107#ifndef NDEBUG
// Verify that the symbol points to a valid entry in the symbol table.
uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base());

assert((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 &&(((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type
) == 0 && "Symbol did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("(Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 && \"Symbol did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 112, __PRETTY_FUNCTION__))
       "Symbol did not point to the beginning of a symbol")(((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type
) == 0 && "Symbol did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("(Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 && \"Symbol did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 112, __PRETTY_FUNCTION__));
113#endif

return Addr;
116}

118const coff_section *COFFObjectFile::toSec(DataRefImpl Ref) const {
const coff_section *Addr = reinterpret_cast<const coff_section*>(Ref.p);

121#ifndef NDEBUG
// Verify that the section points to a valid entry in the section table.
if (Addr < SectionTable || Addr >= (SectionTable + getNumberOfSections()))
  report_fatal_error("Section was outside of section table.");

uintptr_t Offset = uintptr_t(Addr) - uintptr_t(SectionTable);
assert(Offset % sizeof(coff_section) == 0 &&((Offset % sizeof(coff_section) == 0 && "Section did not point to the beginning of a section"
) ? static_cast<void> (0) : __assert_fail ("Offset % sizeof(coff_section) == 0 && \"Section did not point to the beginning of a section\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 128, __PRETTY_FUNCTION__))
       "Section did not point to the beginning of a section")((Offset % sizeof(coff_section) == 0 && "Section did not point to the beginning of a section"
) ? static_cast<void> (0) : __assert_fail ("Offset % sizeof(coff_section) == 0 && \"Section did not point to the beginning of a section\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 128, __PRETTY_FUNCTION__));
129#endif

return Addr;
132}

134void COFFObjectFile::moveSymbolNext(DataRefImpl &Ref) const {
auto End = reinterpret_cast<uintptr_t>(StringTable);
if (SymbolTable16) {
  const coff_symbol16 *Symb = toSymb<coff_symbol16>(Ref);
  Symb += 1 + Symb->NumberOfAuxSymbols;
  Ref.p = std::min(reinterpret_cast<uintptr_t>(Symb), End);
} else if (SymbolTable32) {
  const coff_symbol32 *Symb = toSymb<coff_symbol32>(Ref);
  Symb += 1 + Symb->NumberOfAuxSymbols;
  Ref.p = std::min(reinterpret_cast<uintptr_t>(Symb), End);
} else {
  llvm_unreachable("no symbol table pointer!")::llvm::llvm_unreachable_internal("no symbol table pointer!",
 "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 145);
}
147}

149Expected<StringRef> COFFObjectFile::getSymbolName(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
StringRef Result;
if (std::error_code EC = getSymbolName(Symb, Result))
  return errorCodeToError(EC);
return Result;
155}

157uint64_t COFFObjectFile::getSymbolValueImpl(DataRefImpl Ref) const {
return getCOFFSymbol(Ref).getValue();
159}

161uint32_t COFFObjectFile::getSymbolAlignment(DataRefImpl Ref) const {
// MSVC/link.exe seems to align symbols to the next-power-of-2
// up to 32 bytes.
COFFSymbolRef Symb = getCOFFSymbol(Ref);
return std::min(uint64_t(32), PowerOf2Ceil(Symb.getValue()));
166}

168Expected<uint64_t> COFFObjectFile::getSymbolAddress(DataRefImpl Ref) const {
uint64_t Result = getSymbolValue(Ref);
COFFSymbolRef Symb = getCOFFSymbol(Ref);
int32_t SectionNumber = Symb.getSectionNumber();

if (Symb.isAnyUndefined() || Symb.isCommon() ||
    COFF::isReservedSectionNumber(SectionNumber))
  return Result;

const coff_section *Section = nullptr;
if (std::error_code EC = getSection(SectionNumber, Section))
  return errorCodeToError(EC);
Result += Section->VirtualAddress;

// The section VirtualAddress does not include ImageBase, and we want to
// return virtual addresses.
Result += getImageBase();

return Result;
187}

189Expected<SymbolRef::Type> COFFObjectFile::getSymbolType(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
int32_t SectionNumber = Symb.getSectionNumber();

if (Symb.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION)
  return SymbolRef::ST_Function;
if (Symb.isAnyUndefined())
  return SymbolRef::ST_Unknown;
if (Symb.isCommon())
  return SymbolRef::ST_Data;
if (Symb.isFileRecord())
  return SymbolRef::ST_File;

// TODO: perhaps we need a new symbol type ST_Section.
if (SectionNumber == COFF::IMAGE_SYM_DEBUG || Symb.isSectionDefinition())
  return SymbolRef::ST_Debug;

if (!COFF::isReservedSectionNumber(SectionNumber))
  return SymbolRef::ST_Data;

return SymbolRef::ST_Other;
210}

212uint32_t COFFObjectFile::getSymbolFlags(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
uint32_t Result = SymbolRef::SF_None;

if (Symb.isExternal() || Symb.isWeakExternal())
  Result |= SymbolRef::SF_Global;

if (const coff_aux_weak_external *AWE = Symb.getWeakExternal()) {
  Result |= SymbolRef::SF_Weak;
  if (AWE->Characteristics != COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS)
    Result |= SymbolRef::SF_Undefined;
}

if (Symb.getSectionNumber() == COFF::IMAGE_SYM_ABSOLUTE)
  Result |= SymbolRef::SF_Absolute;

if (Symb.isFileRecord())
  Result |= SymbolRef::SF_FormatSpecific;

if (Symb.isSectionDefinition())
  Result |= SymbolRef::SF_FormatSpecific;

if (Symb.isCommon())
  Result |= SymbolRef::SF_Common;

if (Symb.isUndefined())
  Result |= SymbolRef::SF_Undefined;

return Result;
241}

243uint64_t COFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
return Symb.getValue();
246}

248Expected<section_iterator>
249COFFObjectFile::getSymbolSection(DataRefImpl Ref) const {
COFFSymbolRef Symb = getCOFFSymbol(Ref);
if (COFF::isReservedSectionNumber(Symb.getSectionNumber()))
  return section_end();
const coff_section *Sec = nullptr;
if (std::error_code EC = getSection(Symb.getSectionNumber(), Sec))
  return errorCodeToError(EC);
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(Sec);
return section_iterator(SectionRef(Ret, this));
259}

261unsigned COFFObjectFile::getSymbolSectionID(SymbolRef Sym) const {
COFFSymbolRef Symb = getCOFFSymbol(Sym.getRawDataRefImpl());
return Symb.getSectionNumber();
264}

266void COFFObjectFile::moveSectionNext(DataRefImpl &Ref) const {
const coff_section *Sec = toSec(Ref);
Sec += 1;
Ref.p = reinterpret_cast<uintptr_t>(Sec);
270}

272Expected<StringRef> COFFObjectFile::getSectionName(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
return getSectionName(Sec);
275}

277uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
uint64_t Result = Sec->VirtualAddress;

// The section VirtualAddress does not include ImageBase, and we want to
// return virtual addresses.
Result += getImageBase();
return Result;
285}

287uint64_t COFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
return toSec(Sec) - SectionTable;
289}

291uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const {
return getSectionSize(toSec(Ref));
293}

295Expected<ArrayRef<uint8_t>>
296COFFObjectFile::getSectionContents(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
ArrayRef<uint8_t> Res;
if (Error E = getSectionContents(Sec, Res))
  return std::move(E);
return Res;
302}

304uint64_t COFFObjectFile::getSectionAlignment(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
return Sec->getAlignment();
307}

309bool COFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
return false;
311}

313bool COFFObjectFile::isSectionText(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
return Sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE;
316}

318bool COFFObjectFile::isSectionData(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
return Sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
321}

323bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
const uint32_t BssFlags = COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
                          COFF::IMAGE_SCN_MEM_READ |
                          COFF::IMAGE_SCN_MEM_WRITE;
return (Sec->Characteristics & BssFlags) == BssFlags;
329}

331unsigned COFFObjectFile::getSectionID(SectionRef Sec) const {
uintptr_t Offset =
    uintptr_t(Sec.getRawDataRefImpl().p) - uintptr_t(SectionTable);
assert((Offset % sizeof(coff_section)) == 0)(((Offset % sizeof(coff_section)) == 0) ? static_cast<void
> (0) : __assert_fail ("(Offset % sizeof(coff_section)) == 0"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 334, __PRETTY_FUNCTION__));
return (Offset / sizeof(coff_section)) + 1;
336}

338bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
// In COFF, a virtual section won't have any in-file
// content, so the file pointer to the content will be zero.
return Sec->PointerToRawData == 0;
343}

345static uint32_t getNumberOfRelocations(const coff_section *Sec,
                                     MemoryBufferRef M, const uint8_t *base) {
// The field for the number of relocations in COFF section table is only
// 16-bit wide. If a section has more than 65535 relocations, 0xFFFF is set to
// NumberOfRelocations field, and the actual relocation count is stored in the
// VirtualAddress field in the first relocation entry.
if (Sec->hasExtendedRelocations()) {
  const coff_relocation *FirstReloc;
  if (getObject(FirstReloc, M, reinterpret_cast<const coff_relocation*>(
      base + Sec->PointerToRelocations)))
    return 0;
  // -1 to exclude this first relocation entry.
  return FirstReloc->VirtualAddress - 1;
}
return Sec->NumberOfRelocations;
360}

362static const coff_relocation *
363getFirstReloc(const coff_section *Sec, MemoryBufferRef M, const uint8_t *Base) {
uint64_t NumRelocs = getNumberOfRelocations(Sec, M, Base);
if (!NumRelocs)
  return nullptr;
auto begin = reinterpret_cast<const coff_relocation *>(
    Base + Sec->PointerToRelocations);
if (Sec->hasExtendedRelocations()) {
  // Skip the first relocation entry repurposed to store the number of
  // relocations.
  begin++;
}
if (Binary::checkOffset(M, uintptr_t(begin),
                        sizeof(coff_relocation) * NumRelocs))
  return nullptr;
return begin;
378}

380relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
const coff_relocation *begin = getFirstReloc(Sec, Data, base());
if (begin && Sec->VirtualAddress != 0)
  report_fatal_error("Sections with relocations should have an address of 0");
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(begin);
return relocation_iterator(RelocationRef(Ret, this));
388}

390relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const {
const coff_section *Sec = toSec(Ref);
const coff_relocation *I = getFirstReloc(Sec, Data, base());
if (I)
  I += getNumberOfRelocations(Sec, Data, base());
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(I);
return relocation_iterator(RelocationRef(Ret, this));
398}

400// Initialize the pointer to the symbol table.
401std::error_code COFFObjectFile::initSymbolTablePtr() {
if (COFFHeader)
  if (std::error_code EC = getObject(
          SymbolTable16, Data, base() + getPointerToSymbolTable(),
          (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize()))
    return EC;

if (COFFBigObjHeader)
  if (std::error_code EC = getObject(
          SymbolTable32, Data, base() + getPointerToSymbolTable(),
          (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize()))
    return EC;

// Find string table. The first four byte of the string table contains the
// total size of the string table, including the size field itself. If the
// string table is empty, the value of the first four byte would be 4.
uint32_t StringTableOffset = getPointerToSymbolTable() +
                             getNumberOfSymbols() * getSymbolTableEntrySize();
const uint8_t *StringTableAddr = base() + StringTableOffset;
const ulittle32_t *StringTableSizePtr;
if (std::error_code EC = getObject(StringTableSizePtr, Data, StringTableAddr))
  return EC;
StringTableSize = *StringTableSizePtr;
if (std::error_code EC =
        getObject(StringTable, Data, StringTableAddr, StringTableSize))
  return EC;

// Treat table sizes < 4 as empty because contrary to the PECOFF spec, some
// tools like cvtres write a size of 0 for an empty table instead of 4.
if (StringTableSize < 4)
    StringTableSize = 4;

// Check that the string table is null terminated if has any in it.
if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)
  return  object_error::parse_failed;
return std::error_code();
437}

439uint64_t COFFObjectFile::getImageBase() const {
if (PE32Header)
  return PE32Header->ImageBase;
else if (PE32PlusHeader)
  return PE32PlusHeader->ImageBase;
// This actually comes up in practice.
return 0;
446}

448// Returns the file offset for the given VA.
449std::error_code COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const {
uint64_t ImageBase = getImageBase();
uint64_t Rva = Addr - ImageBase;
assert(Rva <= UINT32_MAX)((Rva <= (4294967295U)) ? static_cast<void> (0) : __assert_fail
 ("Rva <= UINT32_MAX", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 452, __PRETTY_FUNCTION__));
return getRvaPtr((uint32_t)Rva, Res);
454}

456// Returns the file offset for the given RVA.
457std::error_code COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res) const {
for (const SectionRef &S : sections()) {
  const coff_section *Section = getCOFFSection(S);
  uint32_t SectionStart = Section->VirtualAddress;
  uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;
  if (SectionStart <= Addr && Addr < SectionEnd) {
    uint32_t Offset = Addr - SectionStart;
    Res = uintptr_t(base()) + Section->PointerToRawData + Offset;
    return std::error_code();
  }
}
return object_error::parse_failed;
469}

471std::error_code
472COFFObjectFile::getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
                                   ArrayRef<uint8_t> &Contents) const {
for (const SectionRef &S : sections()) {
  const coff_section *Section = getCOFFSection(S);
  uint32_t SectionStart = Section->VirtualAddress;
  // Check if this RVA is within the section bounds. Be careful about integer
  // overflow.
  uint32_t OffsetIntoSection = RVA - SectionStart;
  if (SectionStart <= RVA && OffsetIntoSection < Section->VirtualSize &&
      Size <= Section->VirtualSize - OffsetIntoSection) {
    uintptr_t Begin =
        uintptr_t(base()) + Section->PointerToRawData + OffsetIntoSection;
    Contents =
        ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Begin), Size);
    return std::error_code();
  }
}
return object_error::parse_failed;
490}

492// Returns hint and name fields, assuming \p Rva is pointing to a Hint/Name
493// table entry.
494std::error_code COFFObjectFile::getHintName(uint32_t Rva, uint16_t &Hint,
                                          StringRef &Name) const {
uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(Rva, IntPtr))
  return EC;
const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr);
Hint = *reinterpret_cast<const ulittle16_t *>(Ptr);
Name = StringRef(reinterpret_cast<const char *>(Ptr + 2));
return std::error_code();
503}

505std::error_code
506COFFObjectFile::getDebugPDBInfo(const debug_directory *DebugDir,
                              const codeview::DebugInfo *&PDBInfo,
                              StringRef &PDBFileName) const {
ArrayRef<uint8_t> InfoBytes;
if (std::error_code EC = getRvaAndSizeAsBytes(
        DebugDir->AddressOfRawData, DebugDir->SizeOfData, InfoBytes))
  return EC;
if (InfoBytes.size() < sizeof(*PDBInfo) + 1)
  return object_error::parse_failed;
PDBInfo = reinterpret_cast<const codeview::DebugInfo *>(InfoBytes.data());
InfoBytes = InfoBytes.drop_front(sizeof(*PDBInfo));
PDBFileName = StringRef(reinterpret_cast<const char *>(InfoBytes.data()),
                        InfoBytes.size());
// Truncate the name at the first null byte. Ignore any padding.
PDBFileName = PDBFileName.split('\0').first;
return std::error_code();
522}

524std::error_code
525COFFObjectFile::getDebugPDBInfo(const codeview::DebugInfo *&PDBInfo,
                              StringRef &PDBFileName) const {
for (const debug_directory &D : debug_directories())
  if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW)
    return getDebugPDBInfo(&D, PDBInfo, PDBFileName);
// If we get here, there is no PDB info to return.
PDBInfo = nullptr;
PDBFileName = StringRef();
return std::error_code();
534}

536// Find the import table.
537std::error_code COFFObjectFile::initImportTablePtr() {
// First, we get the RVA of the import table. If the file lacks a pointer to
// the import table, do nothing.
const data_directory *DataEntry;
if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry))
  return std::error_code();

// Do nothing if the pointer to import table is NULL.
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();

uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress;

// Find the section that contains the RVA. This is needed because the RVA is
// the import table's memory address which is different from its file offset.
uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr))
  return EC;
if (std::error_code EC = checkOffset(Data, IntPtr, DataEntry->Size))
  return EC;
ImportDirectory = reinterpret_cast<
    const coff_import_directory_table_entry *>(IntPtr);
return std::error_code();
560}

562// Initializes DelayImportDirectory and NumberOfDelayImportDirectory.
563std::error_code COFFObjectFile::initDelayImportTablePtr() {
const data_directory *DataEntry;
if (getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR, DataEntry))
  return std::error_code();
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();

uint32_t RVA = DataEntry->RelativeVirtualAddress;
NumberOfDelayImportDirectory = DataEntry->Size /
    sizeof(delay_import_directory_table_entry) - 1;

uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(RVA, IntPtr))
  return EC;
DelayImportDirectory = reinterpret_cast<
    const delay_import_directory_table_entry *>(IntPtr);
return std::error_code();
580}

582// Find the export table.
583std::error_code COFFObjectFile::initExportTablePtr() {
// First, we get the RVA of the export table. If the file lacks a pointer to
// the export table, do nothing.
const data_directory *DataEntry;
if (getDataDirectory(COFF::EXPORT_TABLE, DataEntry))
  return std::error_code();

// Do nothing if the pointer to export table is NULL.
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();

uint32_t ExportTableRva = DataEntry->RelativeVirtualAddress;
uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(ExportTableRva, IntPtr))
  return EC;
ExportDirectory =
    reinterpret_cast<const export_directory_table_entry *>(IntPtr);
return std::error_code();
601}

603std::error_code COFFObjectFile::initBaseRelocPtr() {
const data_directory *DataEntry;
if (getDataDirectory(COFF::BASE_RELOCATION_TABLE, DataEntry))
  return std::error_code();
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();

uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr))
  return EC;
BaseRelocHeader = reinterpret_cast<const coff_base_reloc_block_header *>(
    IntPtr);
BaseRelocEnd = reinterpret_cast<coff_base_reloc_block_header *>(
    IntPtr + DataEntry->Size);
// FIXME: Verify the section containing BaseRelocHeader has at least
// DataEntry->Size bytes after DataEntry->RelativeVirtualAddress.
return std::error_code();
620}

622std::error_code COFFObjectFile::initDebugDirectoryPtr() {
// Get the RVA of the debug directory. Do nothing if it does not exist.
const data_directory *DataEntry;
if (getDataDirectory(COFF::DEBUG_DIRECTORY, DataEntry))
  return std::error_code();

// Do nothing if the RVA is NULL.
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();

// Check that the size is a multiple of the entry size.
if (DataEntry->Size % sizeof(debug_directory) != 0)
  return object_error::parse_failed;

uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr))
  return EC;
DebugDirectoryBegin = reinterpret_cast<const debug_directory *>(IntPtr);
DebugDirectoryEnd = reinterpret_cast<const debug_directory *>(
    IntPtr + DataEntry->Size);
// FIXME: Verify the section containing DebugDirectoryBegin has at least
// DataEntry->Size bytes after DataEntry->RelativeVirtualAddress.
return std::error_code();
645}

647std::error_code COFFObjectFile::initLoadConfigPtr() {
// Get the RVA of the debug directory. Do nothing if it does not exist.
const data_directory *DataEntry;
if (getDataDirectory(COFF::LOAD_CONFIG_TABLE, DataEntry))
  return std::error_code();

// Do nothing if the RVA is NULL.
if (DataEntry->RelativeVirtualAddress == 0)
  return std::error_code();
uintptr_t IntPtr = 0;
if (std::error_code EC = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr))
  return EC;

LoadConfig = (const void *)IntPtr;
return std::error_code();
662}

664COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
  : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr),
    COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr),
    DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr),
    SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0),
    ImportDirectory(nullptr),
    DelayImportDirectory(nullptr), NumberOfDelayImportDirectory(0),
    ExportDirectory(nullptr), BaseRelocHeader(nullptr), BaseRelocEnd(nullptr),
    DebugDirectoryBegin(nullptr), DebugDirectoryEnd(nullptr) {
// Check that we at least have enough room for a header.
if (!checkSize(Data, EC, sizeof(coff_file_header)))
  return;

// The current location in the file where we are looking at.
uint64_t CurPtr = 0;

// PE header is optional and is present only in executables. If it exists,
// it is placed right after COFF header.
bool HasPEHeader = false;

// Check if this is a PE/COFF file.
if (checkSize(Data, EC, sizeof(dos_header) + sizeof(COFF::PEMagic))) {
  // PE/COFF, seek through MS-DOS compatibility stub and 4-byte
  // PE signature to find 'normal' COFF header.
  const auto *DH = reinterpret_cast<const dos_header *>(base());
  if (DH->Magic[0] == 'M' && DH->Magic[1] == 'Z') {
    CurPtr = DH->AddressOfNewExeHeader;
    // Check the PE magic bytes. ("PE\0\0")
    if (memcmp(base() + CurPtr, COFF::PEMagic, sizeof(COFF::PEMagic)) != 0) {
      EC = object_error::parse_failed;
      return;
    }
    CurPtr += sizeof(COFF::PEMagic); // Skip the PE magic bytes.
    HasPEHeader = true;
  }
}

if ((EC = getObject(COFFHeader, Data, base() + CurPtr)))
  return;

// It might be a bigobj file, let's check.  Note that COFF bigobj and COFF
// import libraries share a common prefix but bigobj is more restrictive.
if (!HasPEHeader && COFFHeader->Machine == COFF::IMAGE_FILE_MACHINE_UNKNOWN &&
    COFFHeader->NumberOfSections == uint16_t(0xffff) &&
    checkSize(Data, EC, sizeof(coff_bigobj_file_header))) {
  if ((EC = getObject(COFFBigObjHeader, Data, base() + CurPtr)))
    return;

  // Verify that we are dealing with bigobj.
  if (COFFBigObjHeader->Version >= COFF::BigObjHeader::MinBigObjectVersion &&
      std::memcmp(COFFBigObjHeader->UUID, COFF::BigObjMagic,
                  sizeof(COFF::BigObjMagic)) == 0) {
    COFFHeader = nullptr;
    CurPtr += sizeof(coff_bigobj_file_header);
  } else {
    // It's not a bigobj.
    COFFBigObjHeader = nullptr;
  }
}
if (COFFHeader) {
  // The prior checkSize call may have failed.  This isn't a hard error
  // because we were just trying to sniff out bigobj.
  EC = std::error_code();
  CurPtr += sizeof(coff_file_header);

  if (COFFHeader->isImportLibrary())
    return;
}

if (HasPEHeader) {
  const pe32_header *Header;
  if ((EC = getObject(Header, Data, base() + CurPtr)))
    return;

  const uint8_t *DataDirAddr;
  uint64_t DataDirSize;
  if (Header->Magic == COFF::PE32Header::PE32) {
    PE32Header = Header;
    DataDirAddr = base() + CurPtr + sizeof(pe32_header);
    DataDirSize = sizeof(data_directory) * PE32Header->NumberOfRvaAndSize;
  } else if (Header->Magic == COFF::PE32Header::PE32_PLUS) {
    PE32PlusHeader = reinterpret_cast<const pe32plus_header *>(Header);
    DataDirAddr = base() + CurPtr + sizeof(pe32plus_header);
    DataDirSize = sizeof(data_directory) * PE32PlusHeader->NumberOfRvaAndSize;
  } else {
    // It's neither PE32 nor PE32+.
    EC = object_error::parse_failed;
    return;
  }
  if ((EC = getObject(DataDirectory, Data, DataDirAddr, DataDirSize)))
    return;
}

if (COFFHeader)
  CurPtr += COFFHeader->SizeOfOptionalHeader;

if ((EC = getObject(SectionTable, Data, base() + CurPtr,
                    (uint64_t)getNumberOfSections() * sizeof(coff_section))))
  return;

// Initialize the pointer to the symbol table.
if (getPointerToSymbolTable() != 0) {
  if ((EC = initSymbolTablePtr())) {
    SymbolTable16 = nullptr;
    SymbolTable32 = nullptr;
    StringTable = nullptr;
    StringTableSize = 0;
  }
} else {
  // We had better not have any symbols if we don't have a symbol table.
  if (getNumberOfSymbols() != 0) {
    EC = object_error::parse_failed;
    return;
  }
}

// Initialize the pointer to the beginning of the import table.
if ((EC = initImportTablePtr()))
  return;
if ((EC = initDelayImportTablePtr()))
  return;

// Initialize the pointer to the export table.
if ((EC = initExportTablePtr()))
  return;

// Initialize the pointer to the base relocation table.
if ((EC = initBaseRelocPtr()))
  return;

// Initialize the pointer to the export table.
if ((EC = initDebugDirectoryPtr()))
  return;

if ((EC = initLoadConfigPtr()))
  return;

EC = std::error_code();
802}

804basic_symbol_iterator COFFObjectFile::symbol_begin() const {
DataRefImpl Ret;
Ret.p = getSymbolTable();
return basic_symbol_iterator(SymbolRef(Ret, this));
808}

810basic_symbol_iterator COFFObjectFile::symbol_end() const {
// The symbol table ends where the string table begins.
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(StringTable);
return basic_symbol_iterator(SymbolRef(Ret, this));
815}

817import_directory_iterator COFFObjectFile::import_directory_begin() const {
if (!ImportDirectory)
  return import_directory_end();
if (ImportDirectory->isNull())
  return import_directory_end();
return import_directory_iterator(
    ImportDirectoryEntryRef(ImportDirectory, 0, this));
824}

826import_directory_iterator COFFObjectFile::import_directory_end() const {
return import_directory_iterator(
    ImportDirectoryEntryRef(nullptr, -1, this));
829}

831delay_import_directory_iterator
832COFFObjectFile::delay_import_directory_begin() const {
return delay_import_directory_iterator(
    DelayImportDirectoryEntryRef(DelayImportDirectory, 0, this));
835}

837delay_import_directory_iterator
838COFFObjectFile::delay_import_directory_end() const {
return delay_import_directory_iterator(
    DelayImportDirectoryEntryRef(
        DelayImportDirectory, NumberOfDelayImportDirectory, this));
842}

844export_directory_iterator COFFObjectFile::export_directory_begin() const {
return export_directory_iterator(
    ExportDirectoryEntryRef(ExportDirectory, 0, this));
847}

849export_directory_iterator COFFObjectFile::export_directory_end() const {
if (!ExportDirectory)
  return export_directory_iterator(ExportDirectoryEntryRef(nullptr, 0, this));
ExportDirectoryEntryRef Ref(ExportDirectory,
                            ExportDirectory->AddressTableEntries, this);
return export_directory_iterator(Ref);
855}

857section_iterator COFFObjectFile::section_begin() const {
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(SectionTable);
return section_iterator(SectionRef(Ret, this));
861}

863section_iterator COFFObjectFile::section_end() const {
DataRefImpl Ret;
int NumSections =
    COFFHeader && COFFHeader->isImportLibrary() ? 0 : getNumberOfSections();
Ret.p = reinterpret_cast<uintptr_t>(SectionTable + NumSections);
return section_iterator(SectionRef(Ret, this));
869}

871base_reloc_iterator COFFObjectFile::base_reloc_begin() const {
return base_reloc_iterator(BaseRelocRef(BaseRelocHeader, this));
873}

875base_reloc_iterator COFFObjectFile::base_reloc_end() const {
return base_reloc_iterator(BaseRelocRef(BaseRelocEnd, this));
877}

879uint8_t COFFObjectFile::getBytesInAddress() const {
return getArch() == Triple::x86_64 || getArch() == Triple::aarch64 ? 8 : 4;
881}

883StringRef COFFObjectFile::getFileFormatName() const {
switch(getMachine()) {
case COFF::IMAGE_FILE_MACHINE_I386:
  return "COFF-i386";
case COFF::IMAGE_FILE_MACHINE_AMD64:
  return "COFF-x86-64";
case COFF::IMAGE_FILE_MACHINE_ARMNT:
  return "COFF-ARM";
case COFF::IMAGE_FILE_MACHINE_ARM64:
  return "COFF-ARM64";
default:
  return "COFF-<unknown arch>";
}
896}

898Triple::ArchType COFFObjectFile::getArch() const {
switch (getMachine()) {
case COFF::IMAGE_FILE_MACHINE_I386:
  return Triple::x86;
case COFF::IMAGE_FILE_MACHINE_AMD64:
  return Triple::x86_64;
case COFF::IMAGE_FILE_MACHINE_ARMNT:
  return Triple::thumb;
case COFF::IMAGE_FILE_MACHINE_ARM64:
  return Triple::aarch64;
default:
  return Triple::UnknownArch;
}
911}

913Expected<uint64_t> COFFObjectFile::getStartAddress() const {
if (PE32Header)
  return PE32Header->AddressOfEntryPoint;
return 0;
917}

919iterator_range<import_directory_iterator>
920COFFObjectFile::import_directories() const {
return make_range(import_directory_begin(), import_directory_end());
922}

924iterator_range<delay_import_directory_iterator>
925COFFObjectFile::delay_import_directories() const {
return make_range(delay_import_directory_begin(),
                  delay_import_directory_end());
928}

930iterator_range<export_directory_iterator>
931COFFObjectFile::export_directories() const {
return make_range(export_directory_begin(), export_directory_end());
933}

935iterator_range<base_reloc_iterator> COFFObjectFile::base_relocs() const {
return make_range(base_reloc_begin(), base_reloc_end());
937}

939std::error_code
940COFFObjectFile::getDataDirectory(uint32_t Index,
                               const data_directory *&Res) const {
// Error if there's no data directory or the index is out of range.
if (!DataDirectory) {
  Res = nullptr;
  return object_error::parse_failed;
}
assert(PE32Header || PE32PlusHeader)((PE32Header || PE32PlusHeader) ? static_cast<void> (0)
 : __assert_fail ("PE32Header || PE32PlusHeader", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 947, __PRETTY_FUNCTION__));
uint32_t NumEnt = PE32Header ? PE32Header->NumberOfRvaAndSize
                             : PE32PlusHeader->NumberOfRvaAndSize;
if (Index >= NumEnt) {
  Res = nullptr;
  return object_error::parse_failed;
}
Res = &DataDirectory[Index];
return std::error_code();
956}

958std::error_code COFFObjectFile::getSection(int32_t Index,
                                         const coff_section *&Result) const {
Result = nullptr;
37
←
Null pointer value stored to 'Section'→
if (COFF::isReservedSectionNumber(Index))
38
←
Taking true branch→
  return std::error_code();
if (static_cast<uint32_t>(Index) <= getNumberOfSections()) {
  // We already verified the section table data, so no need to check again.
  Result = SectionTable + (Index - 1);
  return std::error_code();
}
return object_error::parse_failed;
969}

971std::error_code COFFObjectFile::getSection(StringRef SectionName,
                                         const coff_section *&Result) const {
Result = nullptr;
for (const SectionRef &Section : sections()) {
  auto NameOrErr = Section.getName();
  if (!NameOrErr)
    return errorToErrorCode(NameOrErr.takeError());

  if (*NameOrErr == SectionName) {
    Result = getCOFFSection(Section);
    return std::error_code();
  }
}
return object_error::parse_failed;
985}

987std::error_code COFFObjectFile::getString(uint32_t Offset,
                                        StringRef &Result) const {
if (StringTableSize <= 4)
  // Tried to get a string from an empty string table.
  return object_error::parse_failed;
if (Offset >= StringTableSize)
  return object_error::unexpected_eof;
Result = StringRef(StringTable + Offset);
return std::error_code();
996}

998std::error_code COFFObjectFile::getSymbolName(COFFSymbolRef Symbol,
                                            StringRef &Res) const {
return getSymbolName(Symbol.getGeneric(), Res);
1001}

1003std::error_code COFFObjectFile::getSymbolName(const coff_symbol_generic *Symbol,
                                            StringRef &Res) const {
// Check for string table entry. First 4 bytes are 0.
if (Symbol->Name.Offset.Zeroes == 0) {
  if (std::error_code EC = getString(Symbol->Name.Offset.Offset, Res))
    return EC;
  return std::error_code();
}

if (Symbol->Name.ShortName[COFF::NameSize - 1] == 0)
  // Null terminated, let ::strlen figure out the length.
  Res = StringRef(Symbol->Name.ShortName);
else
  // Not null terminated, use all 8 bytes.
  Res = StringRef(Symbol->Name.ShortName, COFF::NameSize);
return std::error_code();
1019}

1021ArrayRef<uint8_t>
1022COFFObjectFile::getSymbolAuxData(COFFSymbolRef Symbol) const {
const uint8_t *Aux = nullptr;

size_t SymbolSize = getSymbolTableEntrySize();
if (Symbol.getNumberOfAuxSymbols() > 0) {
  // AUX data comes immediately after the symbol in COFF
  Aux = reinterpret_cast<const uint8_t *>(Symbol.getRawPtr()) + SymbolSize;
1029#ifndef NDEBUG
  // Verify that the Aux symbol points to a valid entry in the symbol table.
  uintptr_t Offset = uintptr_t(Aux) - uintptr_t(base());
  if (Offset < getPointerToSymbolTable() ||
      Offset >=
          getPointerToSymbolTable() + (getNumberOfSymbols() * SymbolSize))
    report_fatal_error("Aux Symbol data was outside of symbol table.");

  assert((Offset - getPointerToSymbolTable()) % SymbolSize == 0 &&(((Offset - getPointerToSymbolTable()) % SymbolSize == 0 &&
 "Aux Symbol data did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("(Offset - getPointerToSymbolTable()) % SymbolSize == 0 && \"Aux Symbol data did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1038, __PRETTY_FUNCTION__))
         "Aux Symbol data did not point to the beginning of a symbol")(((Offset - getPointerToSymbolTable()) % SymbolSize == 0 &&
 "Aux Symbol data did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("(Offset - getPointerToSymbolTable()) % SymbolSize == 0 && \"Aux Symbol data did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1038, __PRETTY_FUNCTION__));
1039#endif
}
return makeArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize);
1042}

1044uint32_t COFFObjectFile::getSymbolIndex(COFFSymbolRef Symbol) const {
uintptr_t Offset =
    reinterpret_cast<uintptr_t>(Symbol.getRawPtr()) - getSymbolTable();
assert(Offset % getSymbolTableEntrySize() == 0 &&((Offset % getSymbolTableEntrySize() == 0 && "Symbol did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("Offset % getSymbolTableEntrySize() == 0 && \"Symbol did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1048, __PRETTY_FUNCTION__))
       "Symbol did not point to the beginning of a symbol")((Offset % getSymbolTableEntrySize() == 0 && "Symbol did not point to the beginning of a symbol"
) ? static_cast<void> (0) : __assert_fail ("Offset % getSymbolTableEntrySize() == 0 && \"Symbol did not point to the beginning of a symbol\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1048, __PRETTY_FUNCTION__));
size_t Index = Offset / getSymbolTableEntrySize();
assert(Index < getNumberOfSymbols())((Index < getNumberOfSymbols()) ? static_cast<void> (
0) : __assert_fail ("Index < getNumberOfSymbols()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1050, __PRETTY_FUNCTION__));
return Index;
1052}

1054Expected<StringRef>
1055COFFObjectFile::getSectionName(const coff_section *Sec) const {
StringRef Name;
if (Sec->Name[COFF::NameSize - 1] == 0)
  // Null terminated, let ::strlen figure out the length.
  Name = Sec->Name;
else
  // Not null terminated, use all 8 bytes.
  Name = StringRef(Sec->Name, COFF::NameSize);

// Check for string table entry. First byte is '/'.
if (Name.startswith("/")) {
  uint32_t Offset;
  if (Name.startswith("//")) {
    if (decodeBase64StringEntry(Name.substr(2), Offset))
      return createStringError(object_error::parse_failed,
                               "invalid section name");
  } else {
    if (Name.substr(1).getAsInteger(10, Offset))
      return createStringError(object_error::parse_failed,
                               "invalid section name");
  }
  if (std::error_code EC = getString(Offset, Name))
    return errorCodeToError(EC);
}

return Name;
1081}

1083uint64_t COFFObjectFile::getSectionSize(const coff_section *Sec) const {
// SizeOfRawData and VirtualSize change what they represent depending on
// whether or not we have an executable image.
//
// For object files, SizeOfRawData contains the size of section's data;
// VirtualSize should be zero but isn't due to buggy COFF writers.
//
// For executables, SizeOfRawData *must* be a multiple of FileAlignment; the
// actual section size is in VirtualSize.  It is possible for VirtualSize to
// be greater than SizeOfRawData; the contents past that point should be
// considered to be zero.
if (getDOSHeader())
  return std::min(Sec->VirtualSize, Sec->SizeOfRawData);
return Sec->SizeOfRawData;
1097}

1099Error COFFObjectFile::getSectionContents(const coff_section *Sec,
                                       ArrayRef<uint8_t> &Res) const {
// In COFF, a virtual section won't have any in-file
// content, so the file pointer to the content will be zero.
if (Sec->PointerToRawData == 0)
46
←
Called C++ object pointer is null
  return Error::success();
// The only thing that we need to verify is that the contents is contained
// within the file bounds. We don't need to make sure it doesn't cover other
// data, as there's nothing that says that is not allowed.
uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData;
uint32_t SectionSize = getSectionSize(Sec);
if (checkOffset(Data, ConStart, SectionSize))
  return make_error<BinaryError>();
Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize);
return Error::success();
1114}

1116const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
return reinterpret_cast<const coff_relocation*>(Rel.p);
1118}

1120void COFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
Rel.p = reinterpret_cast<uintptr_t>(
          reinterpret_cast<const coff_relocation*>(Rel.p) + 1);
1123}

1125uint64_t COFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
const coff_relocation *R = toRel(Rel);
return R->VirtualAddress;
1128}

1130symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
const coff_relocation *R = toRel(Rel);
DataRefImpl Ref;
if (R->SymbolTableIndex >= getNumberOfSymbols())
  return symbol_end();
if (SymbolTable16)
  Ref.p = reinterpret_cast<uintptr_t>(SymbolTable16 + R->SymbolTableIndex);
else if (SymbolTable32)
  Ref.p = reinterpret_cast<uintptr_t>(SymbolTable32 + R->SymbolTableIndex);
else
  llvm_unreachable("no symbol table pointer!")::llvm::llvm_unreachable_internal("no symbol table pointer!",
 "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1140);
return symbol_iterator(SymbolRef(Ref, this));
1142}

1144uint64_t COFFObjectFile::getRelocationType(DataRefImpl Rel) const {
const coff_relocation* R = toRel(Rel);
return R->Type;
1147}

1149const coff_section *
1150COFFObjectFile::getCOFFSection(const SectionRef &Section) const {
return toSec(Section.getRawDataRefImpl());
1152}

1154COFFSymbolRef COFFObjectFile::getCOFFSymbol(const DataRefImpl &Ref) const {
if (SymbolTable16)
  return toSymb<coff_symbol16>(Ref);
if (SymbolTable32)
  return toSymb<coff_symbol32>(Ref);
llvm_unreachable("no symbol table pointer!")::llvm::llvm_unreachable_internal("no symbol table pointer!",
 "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1159);
1160}

1162COFFSymbolRef COFFObjectFile::getCOFFSymbol(const SymbolRef &Symbol) const {
return getCOFFSymbol(Symbol.getRawDataRefImpl());
1164}

1166const coff_relocation *
1167COFFObjectFile::getCOFFRelocation(const RelocationRef &Reloc) const {
return toRel(Reloc.getRawDataRefImpl());
1169}

1171ArrayRef<coff_relocation>
1172COFFObjectFile::getRelocations(const coff_section *Sec) const {
return {getFirstReloc(Sec, Data, base()),
        getNumberOfRelocations(Sec, Data, base())};
1175}

1177#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type)                           \
case COFF::reloc_type:                                                       \
  return #reloc_type;

1181StringRef COFFObjectFile::getRelocationTypeName(uint16_t Type) const {
switch (getMachine()) {
case COFF::IMAGE_FILE_MACHINE_AMD64:
  switch (Type) {
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32NB);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_1);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_2);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_3);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_4);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_5);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECTION);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL7);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_TOKEN);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SREL32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32);
  default:
    return "Unknown";
  }
  break;
case COFF::IMAGE_FILE_MACHINE_ARMNT:
  switch (Type) {
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ABSOLUTE);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32NB);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH11);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_TOKEN);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX24);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX11);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_REL32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECTION);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECREL);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32A);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32T);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH20T);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24T);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX23T);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_PAIR);
  default:
    return "Unknown";
  }
  break;
case COFF::IMAGE_FILE_MACHINE_ARM64:
  switch (Type) {
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ABSOLUTE);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR32NB);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH26);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEBASE_REL21);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_REL21);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEOFFSET_12A);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_PAGEOFFSET_12L);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_LOW12A);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_HIGH12A);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECREL_LOW12L);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_TOKEN);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_SECTION);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_ADDR64);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH19);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_BRANCH14);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM64_REL32);
  default:
    return "Unknown";
  }
  break;
case COFF::IMAGE_FILE_MACHINE_I386:
  switch (Type) {
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32NB);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SEG12);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECTION);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_TOKEN);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7);
  LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32);
  default:
    return "Unknown";
  }
  break;
default:
  return "Unknown";
}
1273}

1275#undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME

1277void COFFObjectFile::getRelocationTypeName(
  DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
const coff_relocation *Reloc = toRel(Rel);
StringRef Res = getRelocationTypeName(Reloc->Type);
Result.append(Res.begin(), Res.end());
1282}

1284bool COFFObjectFile::isRelocatableObject() const {
return !DataDirectory;
1286}

1288StringRef COFFObjectFile::mapDebugSectionName(StringRef Name) const {
return StringSwitch<StringRef>(Name)
    .Case("eh_fram", "eh_frame")
    .Default(Name);
1292}

1294bool ImportDirectoryEntryRef::
1295operator==(const ImportDirectoryEntryRef &Other) const {
return ImportTable == Other.ImportTable && Index == Other.Index;
1297}

1299void ImportDirectoryEntryRef::moveNext() {
++Index;
if (ImportTable[Index].isNull()) {
  Index = -1;
  ImportTable = nullptr;
}
1305}

1307std::error_code ImportDirectoryEntryRef::getImportTableEntry(
  const coff_import_directory_table_entry *&Result) const {
return getObject(Result, OwningObject->Data, ImportTable + Index);
1310}

1312static imported_symbol_iterator
1313makeImportedSymbolIterator(const COFFObjectFile *Object,
                         uintptr_t Ptr, int Index) {
if (Object->getBytesInAddress() == 4) {
  auto *P = reinterpret_cast<const import_lookup_table_entry32 *>(Ptr);
  return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object));
}
auto *P = reinterpret_cast<const import_lookup_table_entry64 *>(Ptr);
return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object));
1321}

1323static imported_symbol_iterator
1324importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object) {
uintptr_t IntPtr = 0;
Object->getRvaPtr(RVA, IntPtr);
return makeImportedSymbolIterator(Object, IntPtr, 0);
1328}

1330static imported_symbol_iterator
1331importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object) {
uintptr_t IntPtr = 0;
Object->getRvaPtr(RVA, IntPtr);
// Forward the pointer to the last entry which is null.
int Index = 0;
if (Object->getBytesInAddress() == 4) {
  auto *Entry = reinterpret_cast<ulittle32_t *>(IntPtr);
  while (*Entry++)
    ++Index;
} else {
  auto *Entry = reinterpret_cast<ulittle64_t *>(IntPtr);
  while (*Entry++)
    ++Index;
}
return makeImportedSymbolIterator(Object, IntPtr, Index);
1346}

1348imported_symbol_iterator
1349ImportDirectoryEntryRef::imported_symbol_begin() const {
return importedSymbolBegin(ImportTable[Index].ImportAddressTableRVA,
                           OwningObject);
1352}

1354imported_symbol_iterator
1355ImportDirectoryEntryRef::imported_symbol_end() const {
return importedSymbolEnd(ImportTable[Index].ImportAddressTableRVA,
                         OwningObject);
1358}

1360iterator_range<imported_symbol_iterator>
1361ImportDirectoryEntryRef::imported_symbols() const {
return make_range(imported_symbol_begin(), imported_symbol_end());
1363}

1365imported_symbol_iterator ImportDirectoryEntryRef::lookup_table_begin() const {
return importedSymbolBegin(ImportTable[Index].ImportLookupTableRVA,
                           OwningObject);
1368}

1370imported_symbol_iterator ImportDirectoryEntryRef::lookup_table_end() const {
return importedSymbolEnd(ImportTable[Index].ImportLookupTableRVA,
                         OwningObject);
1373}

1375iterator_range<imported_symbol_iterator>
1376ImportDirectoryEntryRef::lookup_table_symbols() const {
return make_range(lookup_table_begin(), lookup_table_end());
1378}

1380std::error_code ImportDirectoryEntryRef::getName(StringRef &Result) const {
uintptr_t IntPtr = 0;
if (std::error_code EC =
        OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr))
  return EC;
Result = StringRef(reinterpret_cast<const char *>(IntPtr));
return std::error_code();
1387}

1389std::error_code
1390ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t  &Result) const {
Result = ImportTable[Index].ImportLookupTableRVA;
return std::error_code();
1393}

1395std::error_code
1396ImportDirectoryEntryRef::getImportAddressTableRVA(uint32_t &Result) const {
Result = ImportTable[Index].ImportAddressTableRVA;
return std::error_code();
1399}

1401bool DelayImportDirectoryEntryRef::
1402operator==(const DelayImportDirectoryEntryRef &Other) const {
return Table == Other.Table && Index == Other.Index;
1404}

1406void DelayImportDirectoryEntryRef::moveNext() {
++Index;
1408}

1410imported_symbol_iterator
1411DelayImportDirectoryEntryRef::imported_symbol_begin() const {
return importedSymbolBegin(Table[Index].DelayImportNameTable,
                           OwningObject);
1414}

1416imported_symbol_iterator
1417DelayImportDirectoryEntryRef::imported_symbol_end() const {
return importedSymbolEnd(Table[Index].DelayImportNameTable,
                         OwningObject);
1420}

1422iterator_range<imported_symbol_iterator>
1423DelayImportDirectoryEntryRef::imported_symbols() const {
return make_range(imported_symbol_begin(), imported_symbol_end());
1425}

1427std::error_code DelayImportDirectoryEntryRef::getName(StringRef &Result) const {
uintptr_t IntPtr = 0;
if (std::error_code EC = OwningObject->getRvaPtr(Table[Index].Name, IntPtr))
  return EC;
Result = StringRef(reinterpret_cast<const char *>(IntPtr));
return std::error_code();
1433}

1435std::error_code DelayImportDirectoryEntryRef::
1436getDelayImportTable(const delay_import_directory_table_entry *&Result) const {
Result = &Table[Index];
return std::error_code();
1439}

1441std::error_code DelayImportDirectoryEntryRef::
1442getImportAddress(int AddrIndex, uint64_t &Result) const {
uint32_t RVA = Table[Index].DelayImportAddressTable +
    AddrIndex * (OwningObject->is64() ? 8 : 4);
uintptr_t IntPtr = 0;
if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
  return EC;
if (OwningObject->is64())
  Result = *reinterpret_cast<const ulittle64_t *>(IntPtr);
else
  Result = *reinterpret_cast<const ulittle32_t *>(IntPtr);
return std::error_code();
1453}

1455bool ExportDirectoryEntryRef::
1456operator==(const ExportDirectoryEntryRef &Other) const {
return ExportTable == Other.ExportTable && Index == Other.Index;
1458}

1460void ExportDirectoryEntryRef::moveNext() {
++Index;
1462}

1464// Returns the name of the current export symbol. If the symbol is exported only
1465// by ordinal, the empty string is set as a result.
1466std::error_code ExportDirectoryEntryRef::getDllName(StringRef &Result) const {
uintptr_t IntPtr = 0;
if (std::error_code EC =
        OwningObject->getRvaPtr(ExportTable->NameRVA, IntPtr))
  return EC;
Result = StringRef(reinterpret_cast<const char *>(IntPtr));
return std::error_code();
1473}

1475// Returns the starting ordinal number.
1476std::error_code
1477ExportDirectoryEntryRef::getOrdinalBase(uint32_t &Result) const {
Result = ExportTable->OrdinalBase;
return std::error_code();
1480}

1482// Returns the export ordinal of the current export symbol.
1483std::error_code ExportDirectoryEntryRef::getOrdinal(uint32_t &Result) const {
Result = ExportTable->OrdinalBase + Index;
return std::error_code();
1486}

1488// Returns the address of the current export symbol.
1489std::error_code ExportDirectoryEntryRef::getExportRVA(uint32_t &Result) const {
uintptr_t IntPtr = 0;
if (std::error_code EC =
        OwningObject->getRvaPtr(ExportTable->ExportAddressTableRVA, IntPtr))
  return EC;
const export_address_table_entry *entry =
    reinterpret_cast<const export_address_table_entry *>(IntPtr);
Result = entry[Index].ExportRVA;
return std::error_code();
1498}

1500// Returns the name of the current export symbol. If the symbol is exported only
1501// by ordinal, the empty string is set as a result.
1502std::error_code
1503ExportDirectoryEntryRef::getSymbolName(StringRef &Result) const {
uintptr_t IntPtr = 0;
if (std::error_code EC =
        OwningObject->getRvaPtr(ExportTable->OrdinalTableRVA, IntPtr))
  return EC;
const ulittle16_t *Start = reinterpret_cast<const ulittle16_t *>(IntPtr);

uint32_t NumEntries = ExportTable->NumberOfNamePointers;
int Offset = 0;
for (const ulittle16_t *I = Start, *E = Start + NumEntries;
     I < E; ++I, ++Offset) {
  if (*I != Index)
    continue;
  if (std::error_code EC =
          OwningObject->getRvaPtr(ExportTable->NamePointerRVA, IntPtr))
    return EC;
  const ulittle32_t *NamePtr = reinterpret_cast<const ulittle32_t *>(IntPtr);
  if (std::error_code EC = OwningObject->getRvaPtr(NamePtr[Offset], IntPtr))
    return EC;
  Result = StringRef(reinterpret_cast<const char *>(IntPtr));
  return std::error_code();
}
Result = "";
return std::error_code();
1527}

1529std::error_code ExportDirectoryEntryRef::isForwarder(bool &Result) const {
const data_directory *DataEntry;
if (auto EC = OwningObject->getDataDirectory(COFF::EXPORT_TABLE, DataEntry))
  return EC;
uint32_t RVA;
if (auto EC = getExportRVA(RVA))
  return EC;
uint32_t Begin = DataEntry->RelativeVirtualAddress;
uint32_t End = DataEntry->RelativeVirtualAddress + DataEntry->Size;
Result = (Begin <= RVA && RVA < End);
return std::error_code();
1540}

1542std::error_code ExportDirectoryEntryRef::getForwardTo(StringRef &Result) const {
uint32_t RVA;
if (auto EC = getExportRVA(RVA))
  return EC;
uintptr_t IntPtr = 0;
if (auto EC = OwningObject->getRvaPtr(RVA, IntPtr))
  return EC;
Result = StringRef(reinterpret_cast<const char *>(IntPtr));
return std::error_code();
1551}

1553bool ImportedSymbolRef::
1554operator==(const ImportedSymbolRef &Other) const {
return Entry32 == Other.Entry32 && Entry64 == Other.Entry64
    && Index == Other.Index;
1557}

1559void ImportedSymbolRef::moveNext() {
++Index;
1561}

1563std::error_code
1564ImportedSymbolRef::getSymbolName(StringRef &Result) const {
uint32_t RVA;
if (Entry32) {
  // If a symbol is imported only by ordinal, it has no name.
  if (Entry32[Index].isOrdinal())
    return std::error_code();
  RVA = Entry32[Index].getHintNameRVA();
} else {
  if (Entry64[Index].isOrdinal())
    return std::error_code();
  RVA = Entry64[Index].getHintNameRVA();
}
uintptr_t IntPtr = 0;
if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
  return EC;
// +2 because the first two bytes is hint.
Result = StringRef(reinterpret_cast<const char *>(IntPtr + 2));
return std::error_code();
1582}

1584std::error_code ImportedSymbolRef::isOrdinal(bool &Result) const {
if (Entry32)
  Result = Entry32[Index].isOrdinal();
else
  Result = Entry64[Index].isOrdinal();
return std::error_code();
1590}

1592std::error_code ImportedSymbolRef::getHintNameRVA(uint32_t &Result) const {
if (Entry32)
  Result = Entry32[Index].getHintNameRVA();
else
  Result = Entry64[Index].getHintNameRVA();
return std::error_code();
1598}

1600std::error_code ImportedSymbolRef::getOrdinal(uint16_t &Result) const {
uint32_t RVA;
if (Entry32) {
  if (Entry32[Index].isOrdinal()) {
    Result = Entry32[Index].getOrdinal();
    return std::error_code();
  }
  RVA = Entry32[Index].getHintNameRVA();
} else {
  if (Entry64[Index].isOrdinal()) {
    Result = Entry64[Index].getOrdinal();
    return std::error_code();
  }
  RVA = Entry64[Index].getHintNameRVA();
}
uintptr_t IntPtr = 0;
if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
  return EC;
Result = *reinterpret_cast<const ulittle16_t *>(IntPtr);
return std::error_code();
1620}

1622Expected<std::unique_ptr<COFFObjectFile>>
1623ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) {
std::error_code EC;
std::unique_ptr<COFFObjectFile> Ret(new COFFObjectFile(Object, EC));
if (EC)
  return errorCodeToError(EC);
return std::move(Ret);
1629}

1631bool BaseRelocRef::operator==(const BaseRelocRef &Other) const {
return Header == Other.Header && Index == Other.Index;
1633}

1635void BaseRelocRef::moveNext() {
// Header->BlockSize is the size of the current block, including the
// size of the header itself.
uint32_t Size = sizeof(*Header) +
    sizeof(coff_base_reloc_block_entry) * (Index + 1);
if (Size == Header->BlockSize) {
  // .reloc contains a list of base relocation blocks. Each block
  // consists of the header followed by entries. The header contains
  // how many entories will follow. When we reach the end of the
  // current block, proceed to the next block.
  Header = reinterpret_cast<const coff_base_reloc_block_header *>(
      reinterpret_cast<const uint8_t *>(Header) + Size);
  Index = 0;
} else {
  ++Index;
}
1651}

1653std::error_code BaseRelocRef::getType(uint8_t &Type) const {
auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1);
Type = Entry[Index].getType();
return std::error_code();
1657}

1659std::error_code BaseRelocRef::getRVA(uint32_t &Result) const {
auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1);
Result = Header->PageRVA + Entry[Index].getOffset();
return std::error_code();
1663}

1665#define RETURN_IF_ERROR(Expr)do { Error E = (Expr); if (E) return std::move(E); } while (0
)                                                  \
do {                                                                         \
  Error E = (Expr);                                                          \
  if (E)                                                                     \
    return std::move(E);                                                     \
} while (0)

1672Expected<ArrayRef<UTF16>>
1673ResourceSectionRef::getDirStringAtOffset(uint32_t Offset) {
BinaryStreamReader Reader = BinaryStreamReader(BBS);
Reader.setOffset(Offset);
uint16_t Length;
RETURN_IF_ERROR(Reader.readInteger(Length))do { Error E = (Reader.readInteger(Length)); if (E) return std
::move(E); } while (0);
ArrayRef<UTF16> RawDirString;
RETURN_IF_ERROR(Reader.readArray(RawDirString, Length))do { Error E = (Reader.readArray(RawDirString, Length)); if (
E) return std::move(E); } while (0);
return RawDirString;
1681}

1683Expected<ArrayRef<UTF16>>
1684ResourceSectionRef::getEntryNameString(const coff_resource_dir_entry &Entry) {
return getDirStringAtOffset(Entry.Identifier.getNameOffset());
1686}

1688Expected<const coff_resource_dir_table &>
1689ResourceSectionRef::getTableAtOffset(uint32_t Offset) {
const coff_resource_dir_table *Table = nullptr;

BinaryStreamReader Reader(BBS);
Reader.setOffset(Offset);
RETURN_IF_ERROR(Reader.readObject(Table))do { Error E = (Reader.readObject(Table)); if (E) return std::
move(E); } while (0);
assert(Table != nullptr)((Table != nullptr) ? static_cast<void> (0) : __assert_fail
 ("Table != nullptr", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1695, __PRETTY_FUNCTION__));
return *Table;
1697}

1699Expected<const coff_resource_dir_entry &>
1700ResourceSectionRef::getTableEntryAtOffset(uint32_t Offset) {
const coff_resource_dir_entry *Entry = nullptr;

BinaryStreamReader Reader(BBS);
Reader.setOffset(Offset);
RETURN_IF_ERROR(Reader.readObject(Entry))do { Error E = (Reader.readObject(Entry)); if (E) return std::
move(E); } while (0);
assert(Entry != nullptr)((Entry != nullptr) ? static_cast<void> (0) : __assert_fail
 ("Entry != nullptr", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1706, __PRETTY_FUNCTION__));
return *Entry;
1708}

1710Expected<const coff_resource_data_entry &>
1711ResourceSectionRef::getDataEntryAtOffset(uint32_t Offset) {
const coff_resource_data_entry *Entry = nullptr;

BinaryStreamReader Reader(BBS);
Reader.setOffset(Offset);
RETURN_IF_ERROR(Reader.readObject(Entry))do { Error E = (Reader.readObject(Entry)); if (E) return std::
move(E); } while (0);
assert(Entry != nullptr)((Entry != nullptr) ? static_cast<void> (0) : __assert_fail
 ("Entry != nullptr", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1717, __PRETTY_FUNCTION__));
return *Entry;
1719}

1721Expected<const coff_resource_dir_table &>
1722ResourceSectionRef::getEntrySubDir(const coff_resource_dir_entry &Entry) {
assert(Entry.Offset.isSubDir())((Entry.Offset.isSubDir()) ? static_cast<void> (0) : __assert_fail
 ("Entry.Offset.isSubDir()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1723, __PRETTY_FUNCTION__));
return getTableAtOffset(Entry.Offset.value());
1725}

1727Expected<const coff_resource_data_entry &>
1728ResourceSectionRef::getEntryData(const coff_resource_dir_entry &Entry) {
assert(!Entry.Offset.isSubDir())((!Entry.Offset.isSubDir()) ? static_cast<void> (0) : __assert_fail
 ("!Entry.Offset.isSubDir()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Object/COFFObjectFile.cpp"
, 1729, __PRETTY_FUNCTION__));
return getDataEntryAtOffset(Entry.Offset.value());
1731}

1733Expected<const coff_resource_dir_table &> ResourceSectionRef::getBaseTable() {
return getTableAtOffset(0);
1735}

1737Expected<const coff_resource_dir_entry &>
1738ResourceSectionRef::getTableEntry(const coff_resource_dir_table &Table,
                                uint32_t Index) {
if (Index >= (uint32_t)(Table.NumberOfNameEntries + Table.NumberOfIDEntries))
  return createStringError(object_error::parse_failed, "index out of range");
const uint8_t *TablePtr = reinterpret_cast<const uint8_t *>(&Table);
ptrdiff_t TableOffset = TablePtr - BBS.data().data();
return getTableEntryAtOffset(TableOffset + sizeof(Table) +
                             Index * sizeof(coff_resource_dir_entry));
1746}

1748Error ResourceSectionRef::load(const COFFObjectFile *O) {
for (const SectionRef &S : O->sections()) {
  Expected<StringRef> Name = S.getName();
  if (!Name)
    return Name.takeError();

  if (*Name == ".rsrc" || *Name == ".rsrc$01")
    return load(O, S);
}
return createStringError(object_error::parse_failed,
                         "no resource section found");
1759}

1761Error ResourceSectionRef::load(const COFFObjectFile *O, const SectionRef &S) {
Obj = O;
Section = S;
Expected<StringRef> Contents = Section.getContents();
if (!Contents)
  return Contents.takeError();
BBS = BinaryByteStream(*Contents, support::little);
const coff_section *COFFSect = Obj->getCOFFSection(Section);
ArrayRef<coff_relocation> OrigRelocs = Obj->getRelocations(COFFSect);
Relocs.reserve(OrigRelocs.size());
for (const coff_relocation &R : OrigRelocs)
  Relocs.push_back(&R);
std::sort(Relocs.begin(), Relocs.end(),
          [](const coff_relocation *A, const coff_relocation *B) {
            return A->VirtualAddress < B->VirtualAddress;
          });
return Error::success();
1778}

1780Expected<StringRef>
1781ResourceSectionRef::getContents(const coff_resource_data_entry &Entry) {
if (!Obj)
1
Assuming field 'Obj' is non-null→
2
←
Taking false branch→
  return createStringError(object_error::parse_failed, "no object provided");

// Find a potential relocation at the DataRVA field (first member of
// the coff_resource_data_entry struct).
const uint8_t *EntryPtr = reinterpret_cast<const uint8_t *>(&Entry);
ptrdiff_t EntryOffset = EntryPtr - BBS.data().data();
coff_relocation RelocTarget{ulittle32_t(EntryOffset), ulittle32_t(0),
                            ulittle16_t(0)};
auto RelocsForOffset =
    std::equal_range(Relocs.begin(), Relocs.end(), &RelocTarget,
                     [](const coff_relocation *A, const coff_relocation *B) {
                       return A->VirtualAddress < B->VirtualAddress;
                     });

if (RelocsForOffset.first != RelocsForOffset.second) {
3
←
Calling 'operator!=<const llvm::object::coff_relocation **, std::vector<const llvm::object::coff_relocation *, std::allocator<const llvm::object::coff_relocation *> >>'→
6
←
Returning from 'operator!=<const llvm::object::coff_relocation **, std::vector<const llvm::object::coff_relocation *, std::allocator<const llvm::object::coff_relocation *> >>'→
7
←
Taking true branch→
  // We found a relocation with the right offset. Check that it does have
  // the expected type.
  const coff_relocation &R = **RelocsForOffset.first;
  uint16_t RVAReloc;
  switch (Obj->getMachine()) {
8
←
Calling 'COFFObjectFile::getMachine'→
27
←
Returning from 'COFFObjectFile::getMachine'→
28
←
Control jumps to 'case IMAGE_FILE_MACHINE_ARM64:'  at line 1812→
  case COFF::IMAGE_FILE_MACHINE_I386:
    RVAReloc = COFF::IMAGE_REL_I386_DIR32NB;
    break;
  case COFF::IMAGE_FILE_MACHINE_AMD64:
    RVAReloc = COFF::IMAGE_REL_AMD64_ADDR32NB;
    break;
  case COFF::IMAGE_FILE_MACHINE_ARMNT:
    RVAReloc = COFF::IMAGE_REL_ARM_ADDR32NB;
    break;
  case COFF::IMAGE_FILE_MACHINE_ARM64:
    RVAReloc = COFF::IMAGE_REL_ARM64_ADDR32NB;
    break;
29
←
 Execution continues on line 1819→
  default:
    return createStringError(object_error::parse_failed,
                             "unsupported architecture");
  }
  if (R.Type != RVAReloc)
30
←
Assuming the condition is false→
31
←
Taking false branch→
    return createStringError(object_error::parse_failed,
                             "unexpected relocation type");
  // Get the relocation's symbol
  Expected<COFFSymbolRef> Sym = Obj->getSymbol(R.SymbolTableIndex);
  if (!Sym)
32
←
Calling 'Expected::operator bool'→
34
←
Returning from 'Expected::operator bool'→
35
←
Taking false branch→
    return Sym.takeError();
  const coff_section *Section = nullptr;
  // And the symbol's section
  if (std::error_code EC = Obj->getSection(Sym->getSectionNumber(), Section))
36
←
Calling 'COFFObjectFile::getSection'→
39
←
Returning from 'COFFObjectFile::getSection'→
40
←
Calling 'error_code::operator bool'→
42
←
Returning from 'error_code::operator bool'→
43
←
Taking false branch→
    return errorCodeToError(EC);
  // Add the initial value of DataRVA to the symbol's offset to find the
  // data it points at.
  uint64_t Offset = Entry.DataRVA + Sym->getValue();
  ArrayRef<uint8_t> Contents;
  if (Error E = Obj->getSectionContents(Section, Contents))
44
←
Passing null pointer value via 1st parameter 'Sec'→
45
←
Calling 'COFFObjectFile::getSectionContents'→
    return std::move(E);
  if (Offset + Entry.DataSize > Contents.size())
    return createStringError(object_error::parse_failed,
                             "data outside of section");
  // Return a reference to the data inside the section.
  return StringRef(reinterpret_cast<const char *>(Contents.data()) + Offset,
                   Entry.DataSize);
} else {
  // Relocatable objects need a relocation for the DataRVA field.
  if (Obj->isRelocatableObject())
    return createStringError(object_error::parse_failed,
                             "no relocation found for DataRVA");

  // Locate the section that contains the address that DataRVA points at.
  uint64_t VA = Entry.DataRVA + Obj->getImageBase();
  for (const SectionRef &S : Obj->sections()) {
    if (VA >= S.getAddress() &&
        VA + Entry.DataSize <= S.getAddress() + S.getSize()) {
      uint64_t Offset = VA - S.getAddress();
      Expected<StringRef> Contents = S.getContents();
      if (!Contents)
        return Contents.takeError();
      return Contents->slice(Offset, Offset + Entry.DataSize);
    }
  }
  return createStringError(object_error::parse_failed,
                           "address not found in image");
}
1863}

←

/usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/bits/stl_iterator.h

→

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2016 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/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>
66#include <bits/ptr_traits.h>

68namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
69{
70_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    pointer
    operator->() const
    { return &(operator*()); }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reference
    operator[](difference_type __n) const
    { return *(*this + __n); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward many operations to their underlying base()
 *  iterators.  Others are implemented in terms of one another.
 *
*/
template<typename _Iterator>
  inline bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
327#if __cplusplus201402L < 201103L
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
331#else
  inline auto
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
336#endif
  { return __y.base() - __x.base(); }

template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>
384#if __cplusplus201402L >= 201103L
  // DR 685.
  inline auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
390#else
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
394#endif
  { return __y.base() - __x.base(); }
//@}

398#if __cplusplus201402L >= 201103L
// Same as C++14 make_reverse_iterator but used in C++03 mode too.
template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  __make_reverse_iterator(_Iterator __i)
  { return reverse_iterator<_Iterator>(__i); }

405# if __cplusplus201402L > 201103L
406#  define __cpp_lib_make_reverse_iterator201402 201402

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 2285. make_reverse_iterator
/// Generator function for reverse_iterator.
template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  make_reverse_iterator(_Iterator __i)
  { return reverse_iterator<_Iterator>(__i); }
415# endif
416#endif

418#if __cplusplus201402L >= 201103L
template<typename _Iterator>
  auto
  __niter_base(reverse_iterator<_Iterator> __it)
  -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
  { return __make_reverse_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
  struct __is_move_iterator<reverse_iterator<_Iterator> >
    : __is_move_iterator<_Iterator>
  { };

template<typename _Iterator>
  auto
  __miter_base(reverse_iterator<_Iterator> __it)
  -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
  { return __make_reverse_iterator(__miter_base(__it.base())); }
435#endif

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit
    back_insert_iterator(_Container& __x)
    : container(std::__addressof(__x)) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
475#if __cplusplus201402L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
482#else
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
496#endif

    /// Simply returns *this.
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit front_insert_iterator(_Container& __x)
    : container(std::__addressof(__x)) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
566#if __cplusplus201402L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
573#else
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
587#endif

    /// Simply returns *this.
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;
    typename _Container::iterator iter;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(std::__addressof(__x)), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
677#if __cplusplus201402L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
685#else
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
701#endif

    /// Simply returns *this.
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }

// @} group iterators

740_GLIBCXX_END_NAMESPACE_VERSION
741} // namespace

743namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
744{
745_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() _GLIBCXX_NOEXCEPTnoexcept
    : _M_current(_Iterator()) { }

    explicit
    __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPTnoexcept
    : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i) _GLIBCXX_NOEXCEPTnoexcept
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    reference
    operator*() const _GLIBCXX_NOEXCEPTnoexcept
    { return *_M_current; }

    pointer
    operator->() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current; }

    __normal_iterator&
    operator++() _GLIBCXX_NOEXCEPTnoexcept
    {
++_M_current;
return *this;
    }

    __normal_iterator
    operator++(int) _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    __normal_iterator&
    operator--() _GLIBCXX_NOEXCEPTnoexcept
    {
--_M_current;
return *this;
    }

    __normal_iterator
    operator--(int) _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    reference
    operator[](difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current[__n]; }

    __normal_iterator&
    operator+=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
    { _M_current += __n; return *this; }

    __normal_iterator
    operator+(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current + __n); }

    __normal_iterator&
    operator-=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
    { _M_current -= __n; return *this; }

    __normal_iterator
    operator-(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
    { return __normal_iterator(_M_current - __n); }

    const _Iterator&
    base() const _GLIBCXX_NOEXCEPTnoexcept
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() != __rhs.base(); }
4
←
Assuming the condition is true→
5
←
Returning the value 1, which participates in a condition later→

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() >= __rhs.base(); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
944#if __cplusplus201402L >= 201103L
  // DR 685.
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
  -> decltype(__lhs.base() - __rhs.base())
950#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
954#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  _GLIBCXX_NOEXCEPTnoexcept
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

971_GLIBCXX_END_NAMESPACE_VERSION
972} // namespace

974namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
975{
976_GLIBCXX_BEGIN_NAMESPACE_VERSION

template<typename _Iterator, typename _Container>
  _Iterator
  __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
  { return __it.base(); }

983_GLIBCXX_END_NAMESPACE_VERSION
984} // namespace

986#if __cplusplus201402L >= 201103L

988namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
989{
990_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;
    typedef typename __traits_type::reference		__base_ref;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2106. move_iterator wrapping iterators returning prvalues
    typedef typename conditional<is_reference<__base_ref>::value,
	 typename remove_reference<__base_ref>::type&&,
	 __base_ref>::type		reference;

    move_iterator()
    : _M_current() { }

    explicit
    move_iterator(iterator_type __i)
    : _M_current(__i) { }

    template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

    iterator_type
    base() const
    { return _M_current; }

    reference
    operator*() const
    { return static_cast<reference>(*_M_current); }

    pointer
    operator->() const
    { return _M_current; }

    move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

    move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }
  };

// Note: See __normal_iterator operators note from Gaby to understand
// why there are always 2 versions for most of the move_iterator
// operators.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline auto
  operator-(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(__i); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// Overload for pointers that matches std::move_if_noexcept more closely,
// returning a constant iterator when we don't want to move.
template<typename _Tp, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond<_Tp>::value,
	   const _Tp*, move_iterator<_Tp*>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Tp* __i)
  { return _ReturnType(__i); }

// @} group iterators

template<typename _Iterator>
  auto
  __niter_base(move_iterator<_Iterator> __it)
  -> decltype(make_move_iterator(__niter_base(__it.base())))
  { return make_move_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
  struct __is_move_iterator<move_iterator<_Iterator> >
  {
    enum { __value = 1 };
    typedef __true_type __type;
  };

template<typename _Iterator>
  auto
  __miter_base(move_iterator<_Iterator> __it)
  -> decltype(__miter_base(__it.base()))
  { return __miter_base(__it.base()); }

1247_GLIBCXX_END_NAMESPACE_VERSION
1248} // namespace

1250#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
1251#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
1253#else
1254#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
1255#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
1256#endif // C++11

1258#ifdef _GLIBCXX_DEBUG
1259# include <debug/stl_iterator.h>
1260#endif

1262#endif

←

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h

→

1//===- COFF.h - COFF object file implementation -----------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the COFFObjectFile class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_OBJECT_COFF_H
14#define LLVM_OBJECT_COFF_H

16#include "llvm/ADT/iterator_range.h"
17#include "llvm/BinaryFormat/COFF.h"
18#include "llvm/MC/SubtargetFeature.h"
19#include "llvm/Object/Binary.h"
20#include "llvm/Object/CVDebugRecord.h"
21#include "llvm/Object/Error.h"
22#include "llvm/Object/ObjectFile.h"
23#include "llvm/Support/BinaryByteStream.h"
24#include "llvm/Support/ConvertUTF.h"
25#include "llvm/Support/Endian.h"
26#include "llvm/Support/ErrorHandling.h"
27#include <cassert>
28#include <cstddef>
29#include <cstdint>
30#include <system_error>

32namespace llvm {

34template <typename T> class ArrayRef;

36namespace object {

38class BaseRelocRef;
39class DelayImportDirectoryEntryRef;
40class ExportDirectoryEntryRef;
41class ImportDirectoryEntryRef;
42class ImportedSymbolRef;
43class ResourceSectionRef;

45using import_directory_iterator = content_iterator<ImportDirectoryEntryRef>;
46using delay_import_directory_iterator =
  content_iterator<DelayImportDirectoryEntryRef>;
48using export_directory_iterator = content_iterator<ExportDirectoryEntryRef>;
49using imported_symbol_iterator = content_iterator<ImportedSymbolRef>;
50using base_reloc_iterator = content_iterator<BaseRelocRef>;

52/// The DOS compatible header at the front of all PE/COFF executables.
53struct dos_header {
char                 Magic[2];
support::ulittle16_t UsedBytesInTheLastPage;
support::ulittle16_t FileSizeInPages;
support::ulittle16_t NumberOfRelocationItems;
support::ulittle16_t HeaderSizeInParagraphs;
support::ulittle16_t MinimumExtraParagraphs;
support::ulittle16_t MaximumExtraParagraphs;
support::ulittle16_t InitialRelativeSS;
support::ulittle16_t InitialSP;
support::ulittle16_t Checksum;
support::ulittle16_t InitialIP;
support::ulittle16_t InitialRelativeCS;
support::ulittle16_t AddressOfRelocationTable;
support::ulittle16_t OverlayNumber;
support::ulittle16_t Reserved[4];
support::ulittle16_t OEMid;
support::ulittle16_t OEMinfo;
support::ulittle16_t Reserved2[10];
support::ulittle32_t AddressOfNewExeHeader;
73};

75struct coff_file_header {
support::ulittle16_t Machine;
support::ulittle16_t NumberOfSections;
support::ulittle32_t TimeDateStamp;
support::ulittle32_t PointerToSymbolTable;
support::ulittle32_t NumberOfSymbols;
support::ulittle16_t SizeOfOptionalHeader;
support::ulittle16_t Characteristics;

bool isImportLibrary() const { return NumberOfSections == 0xffff; }
85};

87struct coff_bigobj_file_header {
support::ulittle16_t Sig1;
support::ulittle16_t Sig2;
support::ulittle16_t Version;
support::ulittle16_t Machine;
support::ulittle32_t TimeDateStamp;
uint8_t              UUID[16];
support::ulittle32_t unused1;
support::ulittle32_t unused2;
support::ulittle32_t unused3;
support::ulittle32_t unused4;
support::ulittle32_t NumberOfSections;
support::ulittle32_t PointerToSymbolTable;
support::ulittle32_t NumberOfSymbols;
101};

103/// The 32-bit PE header that follows the COFF header.
104struct pe32_header {
support::ulittle16_t Magic;
uint8_t MajorLinkerVersion;
uint8_t MinorLinkerVersion;
support::ulittle32_t SizeOfCode;
support::ulittle32_t SizeOfInitializedData;
support::ulittle32_t SizeOfUninitializedData;
support::ulittle32_t AddressOfEntryPoint;
support::ulittle32_t BaseOfCode;
support::ulittle32_t BaseOfData;
support::ulittle32_t ImageBase;
support::ulittle32_t SectionAlignment;
support::ulittle32_t FileAlignment;
support::ulittle16_t MajorOperatingSystemVersion;
support::ulittle16_t MinorOperatingSystemVersion;
support::ulittle16_t MajorImageVersion;
support::ulittle16_t MinorImageVersion;
support::ulittle16_t MajorSubsystemVersion;
support::ulittle16_t MinorSubsystemVersion;
support::ulittle32_t Win32VersionValue;
support::ulittle32_t SizeOfImage;
support::ulittle32_t SizeOfHeaders;
support::ulittle32_t CheckSum;
support::ulittle16_t Subsystem;
// FIXME: This should be DllCharacteristics.
support::ulittle16_t DLLCharacteristics;
support::ulittle32_t SizeOfStackReserve;
support::ulittle32_t SizeOfStackCommit;
support::ulittle32_t SizeOfHeapReserve;
support::ulittle32_t SizeOfHeapCommit;
support::ulittle32_t LoaderFlags;
// FIXME: This should be NumberOfRvaAndSizes.
support::ulittle32_t NumberOfRvaAndSize;
137};

139/// The 64-bit PE header that follows the COFF header.
140struct pe32plus_header {
support::ulittle16_t Magic;
uint8_t MajorLinkerVersion;
uint8_t MinorLinkerVersion;
support::ulittle32_t SizeOfCode;
support::ulittle32_t SizeOfInitializedData;
support::ulittle32_t SizeOfUninitializedData;
support::ulittle32_t AddressOfEntryPoint;
support::ulittle32_t BaseOfCode;
support::ulittle64_t ImageBase;
support::ulittle32_t SectionAlignment;
support::ulittle32_t FileAlignment;
support::ulittle16_t MajorOperatingSystemVersion;
support::ulittle16_t MinorOperatingSystemVersion;
support::ulittle16_t MajorImageVersion;
support::ulittle16_t MinorImageVersion;
support::ulittle16_t MajorSubsystemVersion;
support::ulittle16_t MinorSubsystemVersion;
support::ulittle32_t Win32VersionValue;
support::ulittle32_t SizeOfImage;
support::ulittle32_t SizeOfHeaders;
support::ulittle32_t CheckSum;
support::ulittle16_t Subsystem;
support::ulittle16_t DLLCharacteristics;
support::ulittle64_t SizeOfStackReserve;
support::ulittle64_t SizeOfStackCommit;
support::ulittle64_t SizeOfHeapReserve;
support::ulittle64_t SizeOfHeapCommit;
support::ulittle32_t LoaderFlags;
support::ulittle32_t NumberOfRvaAndSize;
170};

172struct data_directory {
support::ulittle32_t RelativeVirtualAddress;
support::ulittle32_t Size;
175};

177struct debug_directory {
support::ulittle32_t Characteristics;
support::ulittle32_t TimeDateStamp;
support::ulittle16_t MajorVersion;
support::ulittle16_t MinorVersion;
support::ulittle32_t Type;
support::ulittle32_t SizeOfData;
support::ulittle32_t AddressOfRawData;
support::ulittle32_t PointerToRawData;
186};

188template <typename IntTy>
189struct import_lookup_table_entry {
IntTy Data;

bool isOrdinal() const { return Data < 0; }

uint16_t getOrdinal() const {
  assert(isOrdinal() && "ILT entry is not an ordinal!")((isOrdinal() && "ILT entry is not an ordinal!") ? static_cast
<void> (0) : __assert_fail ("isOrdinal() && \"ILT entry is not an ordinal!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 195, __PRETTY_FUNCTION__));
  return Data & 0xFFFF;
}

uint32_t getHintNameRVA() const {
  assert(!isOrdinal() && "ILT entry is not a Hint/Name RVA!")((!isOrdinal() && "ILT entry is not a Hint/Name RVA!"
) ? static_cast<void> (0) : __assert_fail ("!isOrdinal() && \"ILT entry is not a Hint/Name RVA!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 200, __PRETTY_FUNCTION__));
  return Data & 0xFFFFFFFF;
}
203};

205using import_lookup_table_entry32 =
  import_lookup_table_entry<support::little32_t>;
207using import_lookup_table_entry64 =
  import_lookup_table_entry<support::little64_t>;

210struct delay_import_directory_table_entry {
// dumpbin reports this field as "Characteristics" instead of "Attributes".
support::ulittle32_t Attributes;
support::ulittle32_t Name;
support::ulittle32_t ModuleHandle;
support::ulittle32_t DelayImportAddressTable;
support::ulittle32_t DelayImportNameTable;
support::ulittle32_t BoundDelayImportTable;
support::ulittle32_t UnloadDelayImportTable;
support::ulittle32_t TimeStamp;
220};

222struct export_directory_table_entry {
support::ulittle32_t ExportFlags;
support::ulittle32_t TimeDateStamp;
support::ulittle16_t MajorVersion;
support::ulittle16_t MinorVersion;
support::ulittle32_t NameRVA;
support::ulittle32_t OrdinalBase;
support::ulittle32_t AddressTableEntries;
support::ulittle32_t NumberOfNamePointers;
support::ulittle32_t ExportAddressTableRVA;
support::ulittle32_t NamePointerRVA;
support::ulittle32_t OrdinalTableRVA;
234};

236union export_address_table_entry {
support::ulittle32_t ExportRVA;
support::ulittle32_t ForwarderRVA;
239};

241using export_name_pointer_table_entry = support::ulittle32_t;
242using export_ordinal_table_entry = support::ulittle16_t;

244struct StringTableOffset {
support::ulittle32_t Zeroes;
support::ulittle32_t Offset;
247};

249template <typename SectionNumberType>
250struct coff_symbol {
union {
  char ShortName[COFF::NameSize];
  StringTableOffset Offset;
} Name;

support::ulittle32_t Value;
SectionNumberType SectionNumber;

support::ulittle16_t Type;

uint8_t StorageClass;
uint8_t NumberOfAuxSymbols;
263};

265using coff_symbol16 = coff_symbol<support::ulittle16_t>;
266using coff_symbol32 = coff_symbol<support::ulittle32_t>;

268// Contains only common parts of coff_symbol16 and coff_symbol32.
269struct coff_symbol_generic {
union {
  char ShortName[COFF::NameSize];
  StringTableOffset Offset;
} Name;
support::ulittle32_t Value;
275};

277struct coff_aux_section_definition;
278struct coff_aux_weak_external;

280class COFFSymbolRef {
281public:
COFFSymbolRef() = default;
COFFSymbolRef(const coff_symbol16 *CS) : CS16(CS) {}
COFFSymbolRef(const coff_symbol32 *CS) : CS32(CS) {}

const void *getRawPtr() const {
  return CS16 ? static_cast<const void *>(CS16) : CS32;
}

const coff_symbol_generic *getGeneric() const {
  if (CS16)
    return reinterpret_cast<const coff_symbol_generic *>(CS16);
  return reinterpret_cast<const coff_symbol_generic *>(CS32);
}

friend bool operator<(COFFSymbolRef A, COFFSymbolRef B) {
  return A.getRawPtr() < B.getRawPtr();
}

bool isBigObj() const {
  if (CS16)
    return false;
  if (CS32)
    return true;
  llvm_unreachable("COFFSymbolRef points to nothing!")::llvm::llvm_unreachable_internal("COFFSymbolRef points to nothing!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 305);
}

const char *getShortName() const {
  return CS16 ? CS16->Name.ShortName : CS32->Name.ShortName;
}

const StringTableOffset &getStringTableOffset() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 313, __PRETTY_FUNCTION__));
  return CS16 ? CS16->Name.Offset : CS32->Name.Offset;
}

uint32_t getValue() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 318, __PRETTY_FUNCTION__));
  return CS16 ? CS16->Value : CS32->Value;
}

int32_t getSectionNumber() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 323, __PRETTY_FUNCTION__));
  if (CS16) {
    // Reserved sections are returned as negative numbers.
    if (CS16->SectionNumber <= COFF::MaxNumberOfSections16)
      return CS16->SectionNumber;
    return static_cast<int16_t>(CS16->SectionNumber);
  }
  return static_cast<int32_t>(CS32->SectionNumber);
}

uint16_t getType() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 334, __PRETTY_FUNCTION__));
  return CS16 ? CS16->Type : CS32->Type;
}

uint8_t getStorageClass() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 339, __PRETTY_FUNCTION__));
  return CS16 ? CS16->StorageClass : CS32->StorageClass;
}

uint8_t getNumberOfAuxSymbols() const {
  assert(isSet() && "COFFSymbolRef points to nothing!")((isSet() && "COFFSymbolRef points to nothing!") ? static_cast
<void> (0) : __assert_fail ("isSet() && \"COFFSymbolRef points to nothing!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 344, __PRETTY_FUNCTION__));
  return CS16 ? CS16->NumberOfAuxSymbols : CS32->NumberOfAuxSymbols;
}

uint8_t getBaseType() const { return getType() & 0x0F; }

uint8_t getComplexType() const {
  return (getType() & 0xF0) >> COFF::SCT_COMPLEX_TYPE_SHIFT;
}

template <typename T> const T *getAux() const {
  return CS16 ? reinterpret_cast<const T *>(CS16 + 1)
              : reinterpret_cast<const T *>(CS32 + 1);
}

const coff_aux_section_definition *getSectionDefinition() const {
  if (!getNumberOfAuxSymbols() ||
      getStorageClass() != COFF::IMAGE_SYM_CLASS_STATIC)
    return nullptr;
  return getAux<coff_aux_section_definition>();
}

const coff_aux_weak_external *getWeakExternal() const {
  if (!getNumberOfAuxSymbols() ||
      getStorageClass() != COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL)
    return nullptr;
  return getAux<coff_aux_weak_external>();
}

bool isAbsolute() const {
  return getSectionNumber() == -1;
}

bool isExternal() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL;
}

bool isCommon() const {
  return isExternal() && getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED &&
         getValue() != 0;
}

bool isUndefined() const {
  return isExternal() && getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED &&
         getValue() == 0;
}

bool isWeakExternal() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
}

bool isFunctionDefinition() const {
  return isExternal() && getBaseType() == COFF::IMAGE_SYM_TYPE_NULL &&
         getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION &&
         !COFF::isReservedSectionNumber(getSectionNumber());
}

bool isFunctionLineInfo() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_FUNCTION;
}

bool isAnyUndefined() const {
  return isUndefined() || isWeakExternal();
}

bool isFileRecord() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_FILE;
}

bool isSection() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_SECTION;
}

bool isSectionDefinition() const {
  // C++/CLI creates external ABS symbols for non-const appdomain globals.
  // These are also followed by an auxiliary section definition.
  bool isAppdomainGlobal =
      getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
      getSectionNumber() == COFF::IMAGE_SYM_ABSOLUTE;
  bool isOrdinarySection = getStorageClass() == COFF::IMAGE_SYM_CLASS_STATIC;
  if (!getNumberOfAuxSymbols())
    return false;
  return isAppdomainGlobal || isOrdinarySection;
}

bool isCLRToken() const {
  return getStorageClass() == COFF::IMAGE_SYM_CLASS_CLR_TOKEN;
}

433private:
bool isSet() const { return CS16 || CS32; }

const coff_symbol16 *CS16 = nullptr;
const coff_symbol32 *CS32 = nullptr;
438};

440struct coff_section {
char Name[COFF::NameSize];
support::ulittle32_t VirtualSize;
support::ulittle32_t VirtualAddress;
support::ulittle32_t SizeOfRawData;
support::ulittle32_t PointerToRawData;
support::ulittle32_t PointerToRelocations;
support::ulittle32_t PointerToLinenumbers;
support::ulittle16_t NumberOfRelocations;
support::ulittle16_t NumberOfLinenumbers;
support::ulittle32_t Characteristics;

// Returns true if the actual number of relocations is stored in
// VirtualAddress field of the first relocation table entry.
bool hasExtendedRelocations() const {
  return (Characteristics & COFF::IMAGE_SCN_LNK_NRELOC_OVFL) &&
         NumberOfRelocations == UINT16_MAX(65535);
}

uint32_t getAlignment() const {
  // The IMAGE_SCN_TYPE_NO_PAD bit is a legacy way of getting to
  // IMAGE_SCN_ALIGN_1BYTES.
  if (Characteristics & COFF::IMAGE_SCN_TYPE_NO_PAD)
    return 1;

  // Bit [20:24] contains section alignment. 0 means use a default alignment
  // of 16.
  uint32_t Shift = (Characteristics >> 20) & 0xF;
  if (Shift > 0)
    return 1U << (Shift - 1);
  return 16;
}
472};

474struct coff_relocation {
support::ulittle32_t VirtualAddress;
support::ulittle32_t SymbolTableIndex;
support::ulittle16_t Type;
478};

480struct coff_aux_function_definition {
support::ulittle32_t TagIndex;
support::ulittle32_t TotalSize;
support::ulittle32_t PointerToLinenumber;
support::ulittle32_t PointerToNextFunction;
char Unused1[2];
486};

488static_assert(sizeof(coff_aux_function_definition) == 18,
            "auxiliary entry must be 18 bytes");

491struct coff_aux_bf_and_ef_symbol {
char Unused1[4];
support::ulittle16_t Linenumber;
char Unused2[6];
support::ulittle32_t PointerToNextFunction;
char Unused3[2];
497};

499static_assert(sizeof(coff_aux_bf_and_ef_symbol) == 18,
            "auxiliary entry must be 18 bytes");

502struct coff_aux_weak_external {
support::ulittle32_t TagIndex;
support::ulittle32_t Characteristics;
char Unused1[10];
506};

508static_assert(sizeof(coff_aux_weak_external) == 18,
            "auxiliary entry must be 18 bytes");

511struct coff_aux_section_definition {
support::ulittle32_t Length;
support::ulittle16_t NumberOfRelocations;
support::ulittle16_t NumberOfLinenumbers;
support::ulittle32_t CheckSum;
support::ulittle16_t NumberLowPart;
uint8_t              Selection;
uint8_t              Unused;
support::ulittle16_t NumberHighPart;
int32_t getNumber(bool IsBigObj) const {
  uint32_t Number = static_cast<uint32_t>(NumberLowPart);
  if (IsBigObj)
    Number |= static_cast<uint32_t>(NumberHighPart) << 16;
  return static_cast<int32_t>(Number);
}
526};

528static_assert(sizeof(coff_aux_section_definition) == 18,
            "auxiliary entry must be 18 bytes");

531struct coff_aux_clr_token {
uint8_t              AuxType;
uint8_t              Reserved;
support::ulittle32_t SymbolTableIndex;
char                 MBZ[12];
536};

538static_assert(sizeof(coff_aux_clr_token) == 18,
            "auxiliary entry must be 18 bytes");

541struct coff_import_header {
support::ulittle16_t Sig1;
support::ulittle16_t Sig2;
support::ulittle16_t Version;
support::ulittle16_t Machine;
support::ulittle32_t TimeDateStamp;
support::ulittle32_t SizeOfData;
support::ulittle16_t OrdinalHint;
support::ulittle16_t TypeInfo;

int getType() const { return TypeInfo & 0x3; }
int getNameType() const { return (TypeInfo >> 2) & 0x7; }
553};

555struct coff_import_directory_table_entry {
support::ulittle32_t ImportLookupTableRVA;
support::ulittle32_t TimeDateStamp;
support::ulittle32_t ForwarderChain;
support::ulittle32_t NameRVA;
support::ulittle32_t ImportAddressTableRVA;

bool isNull() const {
  return ImportLookupTableRVA == 0 && TimeDateStamp == 0 &&
         ForwarderChain == 0 && NameRVA == 0 && ImportAddressTableRVA == 0;
}
566};

568template <typename IntTy>
569struct coff_tls_directory {
IntTy StartAddressOfRawData;
IntTy EndAddressOfRawData;
IntTy AddressOfIndex;
IntTy AddressOfCallBacks;
support::ulittle32_t SizeOfZeroFill;
support::ulittle32_t Characteristics;

uint32_t getAlignment() const {
  // Bit [20:24] contains section alignment.
  uint32_t Shift = (Characteristics & 0x00F00000) >> 20;
  if (Shift > 0)
    return 1U << (Shift - 1);
  return 0;
}
584};

586using coff_tls_directory32 = coff_tls_directory<support::little32_t>;
587using coff_tls_directory64 = coff_tls_directory<support::little64_t>;

589/// Bits in control flow guard flags as we understand them.
590enum class coff_guard_flags : uint32_t {
CFInstrumented = 0x00000100,
HasFidTable = 0x00000400,
ProtectDelayLoadIAT = 0x00001000,
DelayLoadIATSection = 0x00002000, // Delay load in separate section
HasLongJmpTable = 0x00010000,
FidTableHasFlags = 0x10000000, // Indicates that fid tables are 5 bytes
597};

599enum class frame_type : uint16_t { Fpo = 0, Trap = 1, Tss = 2, NonFpo = 3 };

601struct coff_load_config_code_integrity {
support::ulittle16_t Flags;
support::ulittle16_t Catalog;
support::ulittle32_t CatalogOffset;
support::ulittle32_t Reserved;
606};

608/// 32-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY32)
609struct coff_load_configuration32 {
support::ulittle32_t Size;
support::ulittle32_t TimeDateStamp;
support::ulittle16_t MajorVersion;
support::ulittle16_t MinorVersion;
support::ulittle32_t GlobalFlagsClear;
support::ulittle32_t GlobalFlagsSet;
support::ulittle32_t CriticalSectionDefaultTimeout;
support::ulittle32_t DeCommitFreeBlockThreshold;
support::ulittle32_t DeCommitTotalFreeThreshold;
support::ulittle32_t LockPrefixTable;
support::ulittle32_t MaximumAllocationSize;
support::ulittle32_t VirtualMemoryThreshold;
support::ulittle32_t ProcessAffinityMask;
support::ulittle32_t ProcessHeapFlags;
support::ulittle16_t CSDVersion;
support::ulittle16_t DependentLoadFlags;
support::ulittle32_t EditList;
support::ulittle32_t SecurityCookie;
support::ulittle32_t SEHandlerTable;
support::ulittle32_t SEHandlerCount;

// Added in MSVC 2015 for /guard:cf.
support::ulittle32_t GuardCFCheckFunction;
support::ulittle32_t GuardCFCheckDispatch;
support::ulittle32_t GuardCFFunctionTable;
support::ulittle32_t GuardCFFunctionCount;
support::ulittle32_t GuardFlags; // coff_guard_flags

// Added in MSVC 2017
coff_load_config_code_integrity CodeIntegrity;
support::ulittle32_t GuardAddressTakenIatEntryTable;
support::ulittle32_t GuardAddressTakenIatEntryCount;
support::ulittle32_t GuardLongJumpTargetTable;
support::ulittle32_t GuardLongJumpTargetCount;
support::ulittle32_t DynamicValueRelocTable;
support::ulittle32_t CHPEMetadataPointer;
support::ulittle32_t GuardRFFailureRoutine;
support::ulittle32_t GuardRFFailureRoutineFunctionPointer;
support::ulittle32_t DynamicValueRelocTableOffset;
support::ulittle16_t DynamicValueRelocTableSection;
support::ulittle16_t Reserved2;
support::ulittle32_t GuardRFVerifyStackPointerFunctionPointer;
support::ulittle32_t HotPatchTableOffset;
653};

655/// 64-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY64)
656struct coff_load_configuration64 {
support::ulittle32_t Size;
support::ulittle32_t TimeDateStamp;
support::ulittle16_t MajorVersion;
support::ulittle16_t MinorVersion;
support::ulittle32_t GlobalFlagsClear;
support::ulittle32_t GlobalFlagsSet;
support::ulittle32_t CriticalSectionDefaultTimeout;
support::ulittle64_t DeCommitFreeBlockThreshold;
support::ulittle64_t DeCommitTotalFreeThreshold;
support::ulittle64_t LockPrefixTable;
support::ulittle64_t MaximumAllocationSize;
support::ulittle64_t VirtualMemoryThreshold;
support::ulittle64_t ProcessAffinityMask;
support::ulittle32_t ProcessHeapFlags;
support::ulittle16_t CSDVersion;
support::ulittle16_t DependentLoadFlags;
support::ulittle64_t EditList;
support::ulittle64_t SecurityCookie;
support::ulittle64_t SEHandlerTable;
support::ulittle64_t SEHandlerCount;

// Added in MSVC 2015 for /guard:cf.
support::ulittle64_t GuardCFCheckFunction;
support::ulittle64_t GuardCFCheckDispatch;
support::ulittle64_t GuardCFFunctionTable;
support::ulittle64_t GuardCFFunctionCount;
support::ulittle32_t GuardFlags;

// Added in MSVC 2017
coff_load_config_code_integrity CodeIntegrity;
support::ulittle64_t GuardAddressTakenIatEntryTable;
support::ulittle64_t GuardAddressTakenIatEntryCount;
support::ulittle64_t GuardLongJumpTargetTable;
support::ulittle64_t GuardLongJumpTargetCount;
support::ulittle64_t DynamicValueRelocTable;
support::ulittle64_t CHPEMetadataPointer;
support::ulittle64_t GuardRFFailureRoutine;
support::ulittle64_t GuardRFFailureRoutineFunctionPointer;
support::ulittle32_t DynamicValueRelocTableOffset;
support::ulittle16_t DynamicValueRelocTableSection;
support::ulittle16_t Reserved2;
support::ulittle64_t GuardRFVerifyStackPointerFunctionPointer;
support::ulittle32_t HotPatchTableOffset;
700};

702struct coff_runtime_function_x64 {
support::ulittle32_t BeginAddress;
support::ulittle32_t EndAddress;
support::ulittle32_t UnwindInformation;
706};

708struct coff_base_reloc_block_header {
support::ulittle32_t PageRVA;
support::ulittle32_t BlockSize;
711};

713struct coff_base_reloc_block_entry {
support::ulittle16_t Data;

int getType() const { return Data >> 12; }
int getOffset() const { return Data & ((1 << 12) - 1); }
718};

720struct coff_resource_dir_entry {
union {
  support::ulittle32_t NameOffset;
  support::ulittle32_t ID;
  uint32_t getNameOffset() const {
    return maskTrailingOnes<uint32_t>(31) & NameOffset;
  }
  // Even though the PE/COFF spec doesn't mention this, the high bit of a name
  // offset is set.
  void setNameOffset(uint32_t Offset) { NameOffset = Offset | (1 << 31); }
} Identifier;
union {
  support::ulittle32_t DataEntryOffset;
  support::ulittle32_t SubdirOffset;

  bool isSubDir() const { return SubdirOffset >> 31; }
  uint32_t value() const {
    return maskTrailingOnes<uint32_t>(31) & SubdirOffset;
  }

} Offset;
741};

743struct coff_resource_data_entry {
support::ulittle32_t DataRVA;
support::ulittle32_t DataSize;
support::ulittle32_t Codepage;
support::ulittle32_t Reserved;
748};

750struct coff_resource_dir_table {
support::ulittle32_t Characteristics;
support::ulittle32_t TimeDateStamp;
support::ulittle16_t MajorVersion;
support::ulittle16_t MinorVersion;
support::ulittle16_t NumberOfNameEntries;
support::ulittle16_t NumberOfIDEntries;
757};

759struct debug_h_header {
support::ulittle32_t Magic;
support::ulittle16_t Version;
support::ulittle16_t HashAlgorithm;
763};

765class COFFObjectFile : public ObjectFile {
766private:
friend class ImportDirectoryEntryRef;
friend class ExportDirectoryEntryRef;
const coff_file_header *COFFHeader;
const coff_bigobj_file_header *COFFBigObjHeader;
const pe32_header *PE32Header;
const pe32plus_header *PE32PlusHeader;
const data_directory *DataDirectory;
const coff_section *SectionTable;
const coff_symbol16 *SymbolTable16;
const coff_symbol32 *SymbolTable32;
const char *StringTable;
uint32_t StringTableSize;
const coff_import_directory_table_entry *ImportDirectory;
const delay_import_directory_table_entry *DelayImportDirectory;
uint32_t NumberOfDelayImportDirectory;
const export_directory_table_entry *ExportDirectory;
const coff_base_reloc_block_header *BaseRelocHeader;
const coff_base_reloc_block_header *BaseRelocEnd;
const debug_directory *DebugDirectoryBegin;
const debug_directory *DebugDirectoryEnd;
// Either coff_load_configuration32 or coff_load_configuration64.
const void *LoadConfig = nullptr;

std::error_code getString(uint32_t offset, StringRef &Res) const;

template <typename coff_symbol_type>
const coff_symbol_type *toSymb(DataRefImpl Symb) const;
const coff_section *toSec(DataRefImpl Sec) const;
const coff_relocation *toRel(DataRefImpl Rel) const;

std::error_code initSymbolTablePtr();
std::error_code initImportTablePtr();
std::error_code initDelayImportTablePtr();
std::error_code initExportTablePtr();
std::error_code initBaseRelocPtr();
std::error_code initDebugDirectoryPtr();
std::error_code initLoadConfigPtr();

805public:
uintptr_t getSymbolTable() const {
  if (SymbolTable16)
    return reinterpret_cast<uintptr_t>(SymbolTable16);
  if (SymbolTable32)
    return reinterpret_cast<uintptr_t>(SymbolTable32);
  return uintptr_t(0);
}

uint16_t getMachine() const {
  if (COFFHeader)
9
←
Assuming field 'COFFHeader' is null→
10
←
Taking false branch→
    return COFFHeader->Machine;
  if (COFFBigObjHeader)
11
←
Assuming field 'COFFBigObjHeader' is non-null→
12
←
Taking true branch→
    return COFFBigObjHeader->Machine;
13
←
Calling 'packed_endian_specific_integral::operator unsigned short'→
25
←
Returning from 'packed_endian_specific_integral::operator unsigned short'→
26
←
Returning value, which participates in a condition later→
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 819);
}

uint16_t getSizeOfOptionalHeader() const {
  if (COFFHeader)
    return COFFHeader->isImportLibrary() ? 0
                                         : COFFHeader->SizeOfOptionalHeader;
  // bigobj doesn't have this field.
  if (COFFBigObjHeader)
    return 0;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 829);
}

uint16_t getCharacteristics() const {
  if (COFFHeader)
    return COFFHeader->isImportLibrary() ? 0 : COFFHeader->Characteristics;
  // bigobj doesn't have characteristics to speak of,
  // editbin will silently lie to you if you attempt to set any.
  if (COFFBigObjHeader)
    return 0;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 839);
}

uint32_t getTimeDateStamp() const {
  if (COFFHeader)
    return COFFHeader->TimeDateStamp;
  if (COFFBigObjHeader)
    return COFFBigObjHeader->TimeDateStamp;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 847);
}

uint32_t getNumberOfSections() const {
  if (COFFHeader)
    return COFFHeader->isImportLibrary() ? 0 : COFFHeader->NumberOfSections;
  if (COFFBigObjHeader)
    return COFFBigObjHeader->NumberOfSections;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 855);
}

uint32_t getPointerToSymbolTable() const {
  if (COFFHeader)
    return COFFHeader->isImportLibrary() ? 0
                                         : COFFHeader->PointerToSymbolTable;
  if (COFFBigObjHeader)
    return COFFBigObjHeader->PointerToSymbolTable;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 864);
}

uint32_t getRawNumberOfSymbols() const {
  if (COFFHeader)
    return COFFHeader->isImportLibrary() ? 0 : COFFHeader->NumberOfSymbols;
  if (COFFBigObjHeader)
    return COFFBigObjHeader->NumberOfSymbols;
  llvm_unreachable("no COFF header!")::llvm::llvm_unreachable_internal("no COFF header!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 872);
}

uint32_t getNumberOfSymbols() const {
  if (!SymbolTable16 && !SymbolTable32)
    return 0;
  return getRawNumberOfSymbols();
}

const coff_load_configuration32 *getLoadConfig32() const {
  assert(!is64())((!is64()) ? static_cast<void> (0) : __assert_fail ("!is64()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 882, __PRETTY_FUNCTION__));
  return reinterpret_cast<const coff_load_configuration32 *>(LoadConfig);
}

const coff_load_configuration64 *getLoadConfig64() const {
  assert(is64())((is64()) ? static_cast<void> (0) : __assert_fail ("is64()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 887, __PRETTY_FUNCTION__));
  return reinterpret_cast<const coff_load_configuration64 *>(LoadConfig);
}
StringRef getRelocationTypeName(uint16_t Type) const;

892protected:
void moveSymbolNext(DataRefImpl &Symb) const override;
Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
uint32_t getSymbolFlags(DataRefImpl Symb) const override;
Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
void moveSectionNext(DataRefImpl &Sec) const override;
Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
uint64_t getSectionAddress(DataRefImpl Sec) const override;
uint64_t getSectionIndex(DataRefImpl Sec) const override;
uint64_t getSectionSize(DataRefImpl Sec) const override;
Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const override;
uint64_t getSectionAlignment(DataRefImpl Sec) const override;
bool isSectionCompressed(DataRefImpl Sec) const override;
bool isSectionText(DataRefImpl Sec) const override;
bool isSectionData(DataRefImpl Sec) const override;
bool isSectionBSS(DataRefImpl Sec) const override;
bool isSectionVirtual(DataRefImpl Sec) const override;
relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
relocation_iterator section_rel_end(DataRefImpl Sec) const override;

void moveRelocationNext(DataRefImpl &Rel) const override;
uint64_t getRelocationOffset(DataRefImpl Rel) const override;
symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
uint64_t getRelocationType(DataRefImpl Rel) const override;
void getRelocationTypeName(DataRefImpl Rel,
                           SmallVectorImpl<char> &Result) const override;

925public:
COFFObjectFile(MemoryBufferRef Object, std::error_code &EC);

basic_symbol_iterator symbol_begin() const override;
basic_symbol_iterator symbol_end() const override;
section_iterator section_begin() const override;
section_iterator section_end() const override;

const coff_section *getCOFFSection(const SectionRef &Section) const;
COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const;
COFFSymbolRef getCOFFSymbol(const SymbolRef &Symbol) const;
const coff_relocation *getCOFFRelocation(const RelocationRef &Reloc) const;
unsigned getSectionID(SectionRef Sec) const;
unsigned getSymbolSectionID(SymbolRef Sym) const;

uint8_t getBytesInAddress() const override;
StringRef getFileFormatName() const override;
Triple::ArchType getArch() const override;
Expected<uint64_t> getStartAddress() const override;
SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }

import_directory_iterator import_directory_begin() const;
import_directory_iterator import_directory_end() const;
delay_import_directory_iterator delay_import_directory_begin() const;
delay_import_directory_iterator delay_import_directory_end() const;
export_directory_iterator export_directory_begin() const;
export_directory_iterator export_directory_end() const;
base_reloc_iterator base_reloc_begin() const;
base_reloc_iterator base_reloc_end() const;
const debug_directory *debug_directory_begin() const {
  return DebugDirectoryBegin;
}
const debug_directory *debug_directory_end() const {
  return DebugDirectoryEnd;
}

iterator_range<import_directory_iterator> import_directories() const;
iterator_range<delay_import_directory_iterator>
    delay_import_directories() const;
iterator_range<export_directory_iterator> export_directories() const;
iterator_range<base_reloc_iterator> base_relocs() const;
iterator_range<const debug_directory *> debug_directories() const {
  return make_range(debug_directory_begin(), debug_directory_end());
}

const dos_header *getDOSHeader() const {
  if (!PE32Header && !PE32PlusHeader)
    return nullptr;
  return reinterpret_cast<const dos_header *>(base());
}

const coff_file_header *getCOFFHeader() const { return COFFHeader; }
const coff_bigobj_file_header *getCOFFBigObjHeader() const {
  return COFFBigObjHeader;
}
const pe32_header *getPE32Header() const { return PE32Header; }
const pe32plus_header *getPE32PlusHeader() const { return PE32PlusHeader; }

std::error_code getDataDirectory(uint32_t index,
                                 const data_directory *&Res) const;
std::error_code getSection(int32_t index, const coff_section *&Res) const;
std::error_code getSection(StringRef SectionName,
                           const coff_section *&Res) const;

template <typename coff_symbol_type>
std::error_code getSymbol(uint32_t Index,
                          const coff_symbol_type *&Res) const {
  if (Index >= getNumberOfSymbols())
    return object_error::parse_failed;

  Res = reinterpret_cast<coff_symbol_type *>(getSymbolTable()) + Index;
  return std::error_code();
}
Expected<COFFSymbolRef> getSymbol(uint32_t index) const {
  if (SymbolTable16) {
    const coff_symbol16 *Symb = nullptr;
    if (std::error_code EC = getSymbol(index, Symb))
      return errorCodeToError(EC);
    return COFFSymbolRef(Symb);
  }
  if (SymbolTable32) {
    const coff_symbol32 *Symb = nullptr;
    if (std::error_code EC = getSymbol(index, Symb))
      return errorCodeToError(EC);
    return COFFSymbolRef(Symb);
  }
  return errorCodeToError(object_error::parse_failed);
}

template <typename T>
std::error_code getAuxSymbol(uint32_t index, const T *&Res) const {
  Expected<COFFSymbolRef> S = getSymbol(index);
  if (Error E = S.takeError())
    return errorToErrorCode(std::move(E));
  Res = reinterpret_cast<const T *>(S->getRawPtr());
  return std::error_code();
}

std::error_code getSymbolName(COFFSymbolRef Symbol, StringRef &Res) const;
std::error_code getSymbolName(const coff_symbol_generic *Symbol,
                              StringRef &Res) const;

ArrayRef<uint8_t> getSymbolAuxData(COFFSymbolRef Symbol) const;

uint32_t getSymbolIndex(COFFSymbolRef Symbol) const;

size_t getSymbolTableEntrySize() const {
  if (COFFHeader)
    return sizeof(coff_symbol16);
  if (COFFBigObjHeader)
    return sizeof(coff_symbol32);
  llvm_unreachable("null symbol table pointer!")::llvm::llvm_unreachable_internal("null symbol table pointer!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Object/COFF.h"
, 1036);
}

ArrayRef<coff_relocation> getRelocations(const coff_section *Sec) const;

Expected<StringRef> getSectionName(const coff_section *Sec) const;
uint64_t getSectionSize(const coff_section *Sec) const;
Error getSectionContents(const coff_section *Sec,
                         ArrayRef<uint8_t> &Res) const;

uint64_t getImageBase() const;
std::error_code getVaPtr(uint64_t VA, uintptr_t &Res) const;
std::error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const;

/// Given an RVA base and size, returns a valid array of bytes or an error
/// code if the RVA and size is not contained completely within a valid
/// section.
std::error_code getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
                                     ArrayRef<uint8_t> &Contents) const;

std::error_code getHintName(uint32_t Rva, uint16_t &Hint,
                            StringRef &Name) const;

/// Get PDB information out of a codeview debug directory entry.
std::error_code getDebugPDBInfo(const debug_directory *DebugDir,
                                const codeview::DebugInfo *&Info,
                                StringRef &PDBFileName) const;

/// Get PDB information from an executable. If the information is not present,
/// Info will be set to nullptr and PDBFileName will be empty. An error is
/// returned only on corrupt object files. Convenience accessor that can be
/// used if the debug directory is not already handy.
std::error_code getDebugPDBInfo(const codeview::DebugInfo *&Info,
                                StringRef &PDBFileName) const;

bool isRelocatableObject() const override;
bool is64() const { return PE32PlusHeader; }

StringRef mapDebugSectionName(StringRef Name) const override;

static bool classof(const Binary *v) { return v->isCOFF(); }
1077};

1079// The iterator for the import directory table.
1080class ImportDirectoryEntryRef {
1081public:
ImportDirectoryEntryRef() = default;
ImportDirectoryEntryRef(const coff_import_directory_table_entry *Table,
                        uint32_t I, const COFFObjectFile *Owner)
    : ImportTable(Table), Index(I), OwningObject(Owner) {}

bool operator==(const ImportDirectoryEntryRef &Other) const;
void moveNext();

imported_symbol_iterator imported_symbol_begin() const;
imported_symbol_iterator imported_symbol_end() const;
iterator_range<imported_symbol_iterator> imported_symbols() const;

imported_symbol_iterator lookup_table_begin() const;
imported_symbol_iterator lookup_table_end() const;
iterator_range<imported_symbol_iterator> lookup_table_symbols() const;

std::error_code getName(StringRef &Result) const;
std::error_code getImportLookupTableRVA(uint32_t &Result) const;
std::error_code getImportAddressTableRVA(uint32_t &Result) const;

std::error_code
getImportTableEntry(const coff_import_directory_table_entry *&Result) const;

1105private:
const coff_import_directory_table_entry *ImportTable;
uint32_t Index;
const COFFObjectFile *OwningObject = nullptr;
1109};

1111class DelayImportDirectoryEntryRef {
1112public:
DelayImportDirectoryEntryRef() = default;
DelayImportDirectoryEntryRef(const delay_import_directory_table_entry *T,
                             uint32_t I, const COFFObjectFile *Owner)
    : Table(T), Index(I), OwningObject(Owner) {}

bool operator==(const DelayImportDirectoryEntryRef &Other) const;
void moveNext();

imported_symbol_iterator imported_symbol_begin() const;
imported_symbol_iterator imported_symbol_end() const;
iterator_range<imported_symbol_iterator> imported_symbols() const;

std::error_code getName(StringRef &Result) const;
std::error_code getDelayImportTable(
    const delay_import_directory_table_entry *&Result) const;
std::error_code getImportAddress(int AddrIndex, uint64_t &Result) const;

1130private:
const delay_import_directory_table_entry *Table;
uint32_t Index;
const COFFObjectFile *OwningObject = nullptr;
1134};

1136// The iterator for the export directory table entry.
1137class ExportDirectoryEntryRef {
1138public:
ExportDirectoryEntryRef() = default;
ExportDirectoryEntryRef(const export_directory_table_entry *Table, uint32_t I,
                        const COFFObjectFile *Owner)
    : ExportTable(Table), Index(I), OwningObject(Owner) {}

bool operator==(const ExportDirectoryEntryRef &Other) const;
void moveNext();

std::error_code getDllName(StringRef &Result) const;
std::error_code getOrdinalBase(uint32_t &Result) const;
std::error_code getOrdinal(uint32_t &Result) const;
std::error_code getExportRVA(uint32_t &Result) const;
std::error_code getSymbolName(StringRef &Result) const;

std::error_code isForwarder(bool &Result) const;
std::error_code getForwardTo(StringRef &Result) const;

1156private:
const export_directory_table_entry *ExportTable;
uint32_t Index;
const COFFObjectFile *OwningObject = nullptr;
1160};

1162class ImportedSymbolRef {
1163public:
ImportedSymbolRef() = default;
ImportedSymbolRef(const import_lookup_table_entry32 *Entry, uint32_t I,
                  const COFFObjectFile *Owner)
    : Entry32(Entry), Entry64(nullptr), Index(I), OwningObject(Owner) {}
ImportedSymbolRef(const import_lookup_table_entry64 *Entry, uint32_t I,
                  const COFFObjectFile *Owner)
    : Entry32(nullptr), Entry64(Entry), Index(I), OwningObject(Owner) {}

bool operator==(const ImportedSymbolRef &Other) const;
void moveNext();

std::error_code getSymbolName(StringRef &Result) const;
std::error_code isOrdinal(bool &Result) const;
std::error_code getOrdinal(uint16_t &Result) const;
std::error_code getHintNameRVA(uint32_t &Result) const;

1180private:
const import_lookup_table_entry32 *Entry32;
const import_lookup_table_entry64 *Entry64;
uint32_t Index;
const COFFObjectFile *OwningObject = nullptr;
1185};

1187class BaseRelocRef {
1188public:
BaseRelocRef() = default;
BaseRelocRef(const coff_base_reloc_block_header *Header,
             const COFFObjectFile *Owner)
    : Header(Header), Index(0) {}

bool operator==(const BaseRelocRef &Other) const;
void moveNext();

std::error_code getType(uint8_t &Type) const;
std::error_code getRVA(uint32_t &Result) const;

1200private:
const coff_base_reloc_block_header *Header;
uint32_t Index;
1203};

1205class ResourceSectionRef {
1206public:
ResourceSectionRef() = default;
explicit ResourceSectionRef(StringRef Ref) : BBS(Ref, support::little) {}

Error load(const COFFObjectFile *O);
Error load(const COFFObjectFile *O, const SectionRef &S);

Expected<ArrayRef<UTF16>>
getEntryNameString(const coff_resource_dir_entry &Entry);
Expected<const coff_resource_dir_table &>
getEntrySubDir(const coff_resource_dir_entry &Entry);
Expected<const coff_resource_data_entry &>
getEntryData(const coff_resource_dir_entry &Entry);
Expected<const coff_resource_dir_table &> getBaseTable();
Expected<const coff_resource_dir_entry &>
getTableEntry(const coff_resource_dir_table &Table, uint32_t Index);

Expected<StringRef> getContents(const coff_resource_data_entry &Entry);

1225private:
BinaryByteStream BBS;

SectionRef Section;
const COFFObjectFile *Obj;

std::vector<const coff_relocation *> Relocs;

Expected<const coff_resource_dir_table &> getTableAtOffset(uint32_t Offset);
Expected<const coff_resource_dir_entry &>
getTableEntryAtOffset(uint32_t Offset);
Expected<const coff_resource_data_entry &>
getDataEntryAtOffset(uint32_t Offset);
Expected<ArrayRef<UTF16>> getDirStringAtOffset(uint32_t Offset);
1239};

1241// Corresponds to `_FPO_DATA` structure in the PE/COFF spec.
1242struct FpoData {
support::ulittle32_t Offset; // ulOffStart: Offset 1st byte of function code
support::ulittle32_t Size;   // cbProcSize: # bytes in function
support::ulittle32_t NumLocals; // cdwLocals: # bytes in locals/4
support::ulittle16_t NumParams; // cdwParams: # bytes in params/4
support::ulittle16_t Attributes;

// cbProlog: # bytes in prolog
int getPrologSize() const { return Attributes & 0xF; }

// cbRegs: # regs saved
int getNumSavedRegs() const { return (Attributes >> 8) & 0x7; }

// fHasSEH: true if seh is func
bool hasSEH() const { return (Attributes >> 9) & 1; }

// fUseBP: true if EBP has been allocated
bool useBP() const { return (Attributes >> 10) & 1; }

// cbFrame: frame pointer
frame_type getFP() const { return static_cast<frame_type>(Attributes >> 14); }
1263};

1265} // end namespace object

1267} // end namespace llvm

1269#endif // LLVM_OBJECT_COFF_H

←

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Support/Endian.h

→

1//===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares generic functions to read and write endian specific data.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_SUPPORT_ENDIAN_H
14#define LLVM_SUPPORT_ENDIAN_H
15 
16#include "llvm/Support/AlignOf.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/Host.h"
19#include "llvm/Support/SwapByteOrder.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23#include <cstring>
24#include <type_traits>
25 
26namespace llvm {
27namespace support {
28 
29enum endianness {big, little, native};
30 
31// These are named values for common alignments.
32enum {aligned = 0, unaligned = 1};
33 
34namespace detail {
35 
36/// ::value is either alignment, or alignof(T) if alignment is 0.
37template<class T, int alignment>
38struct PickAlignment {
39 enum { value = alignment == 0 ? alignof(T) : alignment };
40};
41 
42} // end namespace detail
43 
44namespace endian {
45 
46constexpr endianness system_endianness() {
47  return sys::IsBigEndianHost ? big : little;
48}
49 
50template <typename value_type>
51inline value_type byte_swap(value_type value, endianness endian) {
52  if ((endian != native) && (endian != system_endianness()))
17
←
Assuming 'endian' is equal to native→
53    sys::swapByteOrder(value);
54  return value;
18
←
Returning value (loaded from 'value'), which participates in a condition later→
55}
56 
57/// Swap the bytes of value to match the given endianness.
58template<typename value_type, endianness endian>
59inline value_type byte_swap(value_type value) {
60  return byte_swap(value, endian);
61}
62 
63/// Read a value of a particular endianness from memory.
64template <typename value_type, std::size_t alignment>
65inline value_type read(const void *memory, endianness endian) {
66  value_type ret;
67 
68  memcpy(&ret,
69         LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
70             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
71         sizeof(value_type));
72  return byte_swap<value_type>(ret, endian);
16
←
Calling 'byte_swap<unsigned short>'→
19
←
Returning from 'byte_swap<unsigned short>'→
20
←
Returning value, which participates in a condition later→
73}
74 
75template<typename value_type,
76         endianness endian,
77         std::size_t alignment>
78inline value_type read(const void *memory) {
79  return read<value_type, alignment>(memory, endian);
15
←
Calling 'read<unsigned short, 1>'→
21
←
Returning from 'read<unsigned short, 1>'→
22
←
Returning value, which participates in a condition later→
80}
81 
82/// Read a value of a particular endianness from a buffer, and increment the
83/// buffer past that value.
84template <typename value_type, std::size_t alignment, typename CharT>
85inline value_type readNext(const CharT *&memory, endianness endian) {
86  value_type ret = read<value_type, alignment>(memory, endian);
87  memory += sizeof(value_type);
88  return ret;
89}
90 
91template<typename value_type, endianness endian, std::size_t alignment,
92         typename CharT>
93inline value_type readNext(const CharT *&memory) {
94  return readNext<value_type, alignment, CharT>(memory, endian);
95}
96 
97/// Write a value to memory with a particular endianness.
98template <typename value_type, std::size_t alignment>
99inline void write(void *memory, value_type value, endianness endian) {
100  value = byte_swap<value_type>(value, endian);
101  memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
102             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
103         &value, sizeof(value_type));
104}
105 
106template<typename value_type,
107         endianness endian,
108         std::size_t alignment>
109inline void write(void *memory, value_type value) {
110  write<value_type, alignment>(memory, value, endian);
111}
112 
113template <typename value_type>
114using make_unsigned_t = std::make_unsigned_t<value_type>;
115 
116/// Read a value of a particular endianness from memory, for a location
117/// that starts at the given bit offset within the first byte.
118template <typename value_type, endianness endian, std::size_t alignment>
119inline value_type readAtBitAlignment(const void *memory, uint64_t startBit) {
120  assert(startBit < 8)((startBit < 8) ? static_cast<void> (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Support/Endian.h"
, 120, __PRETTY_FUNCTION__));
121  if (startBit == 0)
122    return read<value_type, endian, alignment>(memory);
123  else {
124    // Read two values and compose the result from them.
125    value_type val[2];
126    memcpy(&val[0],
127           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
128               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
129           sizeof(value_type) * 2);
130    val[0] = byte_swap<value_type, endian>(val[0]);
131    val[1] = byte_swap<value_type, endian>(val[1]);
132 
133    // Shift bits from the lower value into place.
134    make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
135    // Mask off upper bits after right shift in case of signed type.
136    make_unsigned_t<value_type> numBitsFirstVal =
137        (sizeof(value_type) * 8) - startBit;
138    lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
139 
140    // Get the bits from the upper value.
141    make_unsigned_t<value_type> upperVal =
142        val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
143    // Shift them in to place.
144    upperVal <<= numBitsFirstVal;
145 
146    return lowerVal | upperVal;
147  }
148}
149 
150/// Write a value to memory with a particular endianness, for a location
151/// that starts at the given bit offset within the first byte.
152template <typename value_type, endianness endian, std::size_t alignment>
153inline void writeAtBitAlignment(void *memory, value_type value,
154                                uint64_t startBit) {
155  assert(startBit < 8)((startBit < 8) ? static_cast<void> (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Support/Endian.h"
, 155, __PRETTY_FUNCTION__));
156  if (startBit == 0)
157    write<value_type, endian, alignment>(memory, value);
158  else {
159    // Read two values and shift the result into them.
160    value_type val[2];
161    memcpy(&val[0],
162           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
163               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
164           sizeof(value_type) * 2);
165    val[0] = byte_swap<value_type, endian>(val[0]);
166    val[1] = byte_swap<value_type, endian>(val[1]);
167 
168    // Mask off any existing bits in the upper part of the lower value that
169    // we want to replace.
170    val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
171    make_unsigned_t<value_type> numBitsFirstVal =
172        (sizeof(value_type) * 8) - startBit;
173    make_unsigned_t<value_type> lowerVal = value;
174    if (startBit > 0) {
175      // Mask off the upper bits in the new value that are not going to go into
176      // the lower value. This avoids a left shift of a negative value, which
177      // is undefined behavior.
178      lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
179      // Now shift the new bits into place
180      lowerVal <<= startBit;
181    }
182    val[0] |= lowerVal;
183 
184    // Mask off any existing bits in the lower part of the upper value that
185    // we want to replace.
186    val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
187    // Next shift the bits that go into the upper value into position.
188    make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
189    // Mask off upper bits after right shift in case of signed type.
190    upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
191    val[1] |= upperVal;
192 
193    // Finally, rewrite values.
194    val[0] = byte_swap<value_type, endian>(val[0]);
195    val[1] = byte_swap<value_type, endian>(val[1]);
196    memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
197               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
198           &val[0], sizeof(value_type) * 2);
199  }
200}
201 
202} // end namespace endian
203 
204namespace detail {
205 
206template <typename ValueType, endianness Endian, std::size_t Alignment,
207          std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
208struct packed_endian_specific_integral {
209  using value_type = ValueType;
210  static constexpr endianness endian = Endian;
211  static constexpr std::size_t alignment = Alignment;
212 
213  packed_endian_specific_integral() = default;
214 
215  explicit packed_endian_specific_integral(value_type val) { *this = val; }
216 
217  operator value_type() const {
218    return endian::read<value_type, endian, alignment>(
14
←
Calling 'read<unsigned short, llvm::support::little, 1>'→
23
←
Returning from 'read<unsigned short, llvm::support::little, 1>'→
24
←
Returning value, which participates in a condition later→
219      (const void*)Value.buffer);
220  }
221 
222  void operator=(value_type newValue) {
223    endian::write<value_type, endian, alignment>(
224      (void*)Value.buffer, newValue);
225  }
226 
227  packed_endian_specific_integral &operator+=(value_type newValue) {
228    *this = *this + newValue;
229    return *this;
230  }
231 
232  packed_endian_specific_integral &operator-=(value_type newValue) {
233    *this = *this - newValue;
234    return *this;
235  }
236 
237  packed_endian_specific_integral &operator|=(value_type newValue) {
238    *this = *this | newValue;
239    return *this;
240  }
241 
242  packed_endian_specific_integral &operator&=(value_type newValue) {
243    *this = *this & newValue;
244    return *this;
245  }
246 
247private:
248  struct {
249    alignas(ALIGN) char buffer[sizeof(value_type)];
250  } Value;
251 
252public:
253  struct ref {
254    explicit ref(void *Ptr) : Ptr(Ptr) {}
255 
256    operator value_type() const {
257      return endian::read<value_type, endian, alignment>(Ptr);
258    }
259 
260    void operator=(value_type NewValue) {
261      endian::write<value_type, endian, alignment>(Ptr, NewValue);
262    }
263 
264  private:
265    void *Ptr;
266  };
267};
268 
269} // end namespace detail
270 
271using ulittle16_t =
272    detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
273using ulittle32_t =
274    detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
275using ulittle64_t =
276    detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
277 
278using little16_t =
279    detail::packed_endian_specific_integral<int16_t, little, unaligned>;
280using little32_t =
281    detail::packed_endian_specific_integral<int32_t, little, unaligned>;
282using little64_t =
283    detail::packed_endian_specific_integral<int64_t, little, unaligned>;
284 
285using aligned_ulittle16_t =
286    detail::packed_endian_specific_integral<uint16_t, little, aligned>;
287using aligned_ulittle32_t =
288    detail::packed_endian_specific_integral<uint32_t, little, aligned>;
289using aligned_ulittle64_t =
290    detail::packed_endian_specific_integral<uint64_t, little, aligned>;
291 
292using aligned_little16_t =
293    detail::packed_endian_specific_integral<int16_t, little, aligned>;
294using aligned_little32_t =
295    detail::packed_endian_specific_integral<int32_t, little, aligned>;
296using aligned_little64_t =
297    detail::packed_endian_specific_integral<int64_t, little, aligned>;
298 
299using ubig16_t =
300    detail::packed_endian_specific_integral<uint16_t, big, unaligned>;
301using ubig32_t =
302    detail::packed_endian_specific_integral<uint32_t, big, unaligned>;
303using ubig64_t =
304    detail::packed_endian_specific_integral<uint64_t, big, unaligned>;
305 
306using big16_t =
307    detail::packed_endian_specific_integral<int16_t, big, unaligned>;
308using big32_t =
309    detail::packed_endian_specific_integral<int32_t, big, unaligned>;
310using big64_t =
311    detail::packed_endian_specific_integral<int64_t, big, unaligned>;
312 
313using aligned_ubig16_t =
314    detail::packed_endian_specific_integral<uint16_t, big, aligned>;
315using aligned_ubig32_t =
316    detail::packed_endian_specific_integral<uint32_t, big, aligned>;
317using aligned_ubig64_t =
318    detail::packed_endian_specific_integral<uint64_t, big, aligned>;
319 
320using aligned_big16_t =
321    detail::packed_endian_specific_integral<int16_t, big, aligned>;
322using aligned_big32_t =
323    detail::packed_endian_specific_integral<int32_t, big, aligned>;
324using aligned_big64_t =
325    detail::packed_endian_specific_integral<int64_t, big, aligned>;
326 
327using unaligned_uint16_t =
328    detail::packed_endian_specific_integral<uint16_t, native, unaligned>;
329using unaligned_uint32_t =
330    detail::packed_endian_specific_integral<uint32_t, native, unaligned>;
331using unaligned_uint64_t =
332    detail::packed_endian_specific_integral<uint64_t, native, unaligned>;
333 
334using unaligned_int16_t =
335    detail::packed_endian_specific_integral<int16_t, native, unaligned>;
336using unaligned_int32_t =
337    detail::packed_endian_specific_integral<int32_t, native, unaligned>;
338using unaligned_int64_t =
339    detail::packed_endian_specific_integral<int64_t, native, unaligned>;
340 
341template <typename T>
342using little_t = detail::packed_endian_specific_integral<T, little, unaligned>;
343template <typename T>
344using big_t = detail::packed_endian_specific_integral<T, big, unaligned>;
345 
346template <typename T>
347using aligned_little_t =
348    detail::packed_endian_specific_integral<T, little, aligned>;
349template <typename T>
350using aligned_big_t = detail::packed_endian_specific_integral<T, big, aligned>;
351 
352namespace endian {
353 
354template <typename T> inline T read(const void *P, endianness E) {
355  return read<T, unaligned>(P, E);
356}
357 
358template <typename T, endianness E> inline T read(const void *P) {
359  return *(const detail::packed_endian_specific_integral<T, E, unaligned> *)P;
360}
361 
362inline uint16_t read16(const void *P, endianness E) {
363  return read<uint16_t>(P, E);
364}
365inline uint32_t read32(const void *P, endianness E) {
366  return read<uint32_t>(P, E);
367}
368inline uint64_t read64(const void *P, endianness E) {
369  return read<uint64_t>(P, E);
370}
371 
372template <endianness E> inline uint16_t read16(const void *P) {
373  return read<uint16_t, E>(P);
374}
375template <endianness E> inline uint32_t read32(const void *P) {
376  return read<uint32_t, E>(P);
377}
378template <endianness E> inline uint64_t read64(const void *P) {
379  return read<uint64_t, E>(P);
380}
381 
382inline uint16_t read16le(const void *P) { return read16<little>(P); }
383inline uint32_t read32le(const void *P) { return read32<little>(P); }
384inline uint64_t read64le(const void *P) { return read64<little>(P); }
385inline uint16_t read16be(const void *P) { return read16<big>(P); }
386inline uint32_t read32be(const void *P) { return read32<big>(P); }
387inline uint64_t read64be(const void *P) { return read64<big>(P); }
388 
389template <typename T> inline void write(void *P, T V, endianness E) {
390  write<T, unaligned>(P, V, E);
391}
392 
393template <typename T, endianness E> inline void write(void *P, T V) {
394  *(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
395}
396 
397inline void write16(void *P, uint16_t V, endianness E) {
398  write<uint16_t>(P, V, E);
399}
400inline void write32(void *P, uint32_t V, endianness E) {
401  write<uint32_t>(P, V, E);
402}
403inline void write64(void *P, uint64_t V, endianness E) {
404  write<uint64_t>(P, V, E);
405}
406 
407template <endianness E> inline void write16(void *P, uint16_t V) {
408  write<uint16_t, E>(P, V);
409}
410template <endianness E> inline void write32(void *P, uint32_t V) {
411  write<uint32_t, E>(P, V);
412}
413template <endianness E> inline void write64(void *P, uint64_t V) {
414  write<uint64_t, E>(P, V);
415}
416 
417inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
418inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
419inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
420inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
421inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
422inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
423 
424} // end namespace endian
425 
426} // end namespace support
427} // end namespace llvm
428 
429#endif // LLVM_SUPPORT_ENDIAN_H

←

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include/llvm/Support/Error.h

→

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

←

/usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/system_error

1// <system_error> -*- C++ -*-

3// Copyright (C) 2007-2016 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/system_error
*  This is a Standard C++ Library header.
*/

29#ifndef _GLIBCXX_SYSTEM_ERROR1
30#define _GLIBCXX_SYSTEM_ERROR1 1

32#pragma GCC system_header

34#if __cplusplus201402L < 201103L
35# include <bits/c++0x_warning.h>
36#else

38#include <bits/c++config.h>
39#include <bits/error_constants.h>
40#include <iosfwd>
41#include <stdexcept>

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

class error_code;
class error_condition;
class system_error;

/// is_error_code_enum
template<typename _Tp>
  struct is_error_code_enum : public false_type { };

/// is_error_condition_enum
template<typename _Tp>
  struct is_error_condition_enum : public false_type { };

template<> 
  struct is_error_condition_enum<errc>
  : public true_type { };

inline namespace _V2 {

/// error_category
class error_category
{
public:
  constexpr error_category() noexcept = default;

  virtual ~error_category();

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

  virtual const char* 
  name() const noexcept = 0;

  // We need two different virtual functions here, one returning a
  // COW string and one returning an SSO string. Their positions in the
  // vtable must be consistent for dynamic dispatch to work, but which one
  // the name "message()" finds depends on which ABI the caller is using.
83#if _GLIBCXX_USE_CXX11_ABI1
private:
  _GLIBCXX_DEFAULT_ABI_TAG__attribute ((__abi_tag__ ("cxx11")))
  virtual __cow_string
  _M_message(int) const;

public:
  _GLIBCXX_DEFAULT_ABI_TAG__attribute ((__abi_tag__ ("cxx11")))
  virtual string
  message(int) const = 0;
93#else
  virtual string 
  message(int) const = 0;

private:
  virtual __sso_string
  _M_message(int) const;
100#endif

public:
  virtual error_condition
  default_error_condition(int __i) const noexcept;

  virtual bool 
  equivalent(int __i, const error_condition& __cond) const noexcept;

  virtual bool 
  equivalent(const error_code& __code, int __i) const noexcept;

  bool 
  operator<(const error_category& __other) const noexcept
  { return less<const error_category*>()(this, &__other); }

  bool 
  operator==(const error_category& __other) const noexcept
  { return this == &__other; }

  bool 
  operator!=(const error_category& __other) const noexcept
  { return this != &__other; }
};

// DR 890.
_GLIBCXX_CONST__attribute__ ((__const__)) const error_category& system_category() noexcept;
_GLIBCXX_CONST__attribute__ ((__const__)) const error_category& generic_category() noexcept;

} // end inline namespace

error_code make_error_code(errc) noexcept;

template<typename _Tp>
  struct hash;

/// error_code
// Implementation-specific error identification
struct error_code
{
  error_code() noexcept
  : _M_value(0), _M_cat(&system_category()) { }

  error_code(int __v, const error_category& __cat) noexcept
  : _M_value(__v), _M_cat(&__cat) { }

  template<typename _ErrorCodeEnum, typename = typename
    enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
    error_code(_ErrorCodeEnum __e) noexcept
    { *this = make_error_code(__e); }

  void 
  assign(int __v, const error_category& __cat) noexcept
  {
    _M_value = __v;
    _M_cat = &__cat; 
  }

  void 
  clear() noexcept
  { assign(0, system_category()); }

  // DR 804.
  template<typename _ErrorCodeEnum>
    typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
	 error_code&>::type
    operator=(_ErrorCodeEnum __e) noexcept
    { return *this = make_error_code(__e); }

  int
  value() const noexcept { return _M_value; }
    
  const error_category&  
  category() const noexcept { return *_M_cat; }

  error_condition 
  default_error_condition() const noexcept;

  _GLIBCXX_DEFAULT_ABI_TAG__attribute ((__abi_tag__ ("cxx11")))
  string 
  message() const
  { return category().message(value()); }

  explicit operator bool() const noexcept
  { return _M_value != 0; }
41
←
Returning zero, which participates in a condition later→

  // DR 804.
private:
  friend class hash<error_code>;

  int            		_M_value;
  const error_category* 	_M_cat;
};

// 19.4.2.6 non-member functions
inline error_code
make_error_code(errc __e) noexcept
{ return error_code(static_cast<int>(__e), generic_category()); }

inline bool
operator<(const error_code& __lhs, const error_code& __rhs) noexcept
{ 
  return (__lhs.category() < __rhs.category()
   || (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value()));
}

template<typename _CharT, typename _Traits>
  basic_ostream<_CharT, _Traits>&
  operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
  { return (__os << __e.category().name() << ':' << __e.value()); }

error_condition make_error_condition(errc) noexcept;

/// error_condition
// Portable error identification
struct error_condition 
{
  error_condition() noexcept
  : _M_value(0), _M_cat(&generic_category()) { }

  error_condition(int __v, const error_category& __cat) noexcept
  : _M_value(__v), _M_cat(&__cat) { }

  template<typename _ErrorConditionEnum, typename = typename
enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
    error_condition(_ErrorConditionEnum __e) noexcept
    { *this = make_error_condition(__e); }

  void
  assign(int __v, const error_category& __cat) noexcept
  {
    _M_value = __v;
    _M_cat = &__cat;
  }

  // DR 804.
  template<typename _ErrorConditionEnum>
    typename enable_if<is_error_condition_enum
	 <_ErrorConditionEnum>::value, error_condition&>::type
    operator=(_ErrorConditionEnum __e) noexcept
    { return *this = make_error_condition(__e); }

  void 
  clear() noexcept
  { assign(0, generic_category()); }

  // 19.4.3.4 observers
  int
  value() const noexcept { return _M_value; }

  const error_category&
  category() const noexcept { return *_M_cat; }

  _GLIBCXX_DEFAULT_ABI_TAG__attribute ((__abi_tag__ ("cxx11")))
  string 
  message() const
  { return category().message(value()); }

  explicit operator bool() const noexcept
  { return _M_value != 0; }

  // DR 804.
private:
  int 			_M_value;
  const error_category* 	_M_cat;
};

// 19.4.3.6 non-member functions
inline error_condition
make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); }

inline bool 
operator<(const error_condition& __lhs,
   const error_condition& __rhs) noexcept
{
  return (__lhs.category() < __rhs.category()
   || (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value()));
}

// 19.4.4 Comparison operators
inline bool
operator==(const error_code& __lhs, const error_code& __rhs) noexcept
{ return (__lhs.category() == __rhs.category()
   && __lhs.value() == __rhs.value()); }

inline bool
operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
{
  return (__lhs.category().equivalent(__lhs.value(), __rhs)
   || __rhs.category().equivalent(__lhs, __rhs.value()));
}

inline bool
operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
{
  return (__rhs.category().equivalent(__rhs.value(), __lhs)
   || __lhs.category().equivalent(__rhs, __lhs.value()));
}

inline bool
operator==(const error_condition& __lhs,
    const error_condition& __rhs) noexcept
{
  return (__lhs.category() == __rhs.category()
   && __lhs.value() == __rhs.value());
}

inline bool
operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }

inline bool
operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }

inline bool
operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
{ return !(__lhs == __rhs); }

inline bool
operator!=(const error_condition& __lhs,
    const error_condition& __rhs) noexcept
{ return !(__lhs == __rhs); }


/** 
 *  @brief Thrown to indicate error code of underlying system.
 *
 *  @ingroup exceptions
 */
class system_error : public std::runtime_error
{
private:
  error_code 	_M_code;

public:
  system_error(error_code __ec = error_code())
  : runtime_error(__ec.message()), _M_code(__ec) { }

  system_error(error_code __ec, const string& __what)
  : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }

  system_error(error_code __ec, const char* __what)
  : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

  system_error(int __v, const error_category& __ecat, const char* __what)
  : system_error(error_code(__v, __ecat), __what) { }

  system_error(int __v, const error_category& __ecat)
  : runtime_error(error_code(__v, __ecat).message()),
    _M_code(__v, __ecat) { }

  system_error(int __v, const error_category& __ecat, const string& __what)
  : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
    _M_code(__v, __ecat) { }

  virtual ~system_error() noexcept;

  const error_code& 
  code() const noexcept { return _M_code; }
};

365_GLIBCXX_END_NAMESPACE_VERSION
366} // namespace

368#ifndef _GLIBCXX_COMPATIBILITY_CXX0X

370#include <bits/functional_hash.h>

372namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
373{
374_GLIBCXX_BEGIN_NAMESPACE_VERSION

// DR 1182.
/// std::hash specialization for error_code.
template<>
  struct hash<error_code>
  : public __hash_base<size_t, error_code>
  {
    size_t
    operator()(const error_code& __e) const noexcept
    {
const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
    }
  };

390_GLIBCXX_END_NAMESPACE_VERSION
391} // namespace

393#endif // _GLIBCXX_COMPATIBILITY_CXX0X

395#endif // C++11

397#endif // _GLIBCXX_SYSTEM_ERROR