/build/source/llvm/include/llvm/Support/Error.h

Bug Summary

File:	build/source/llvm/include/llvm/Support/Error.h
Warning:	line 519, column 5 Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name llvm-jitlink.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-jitlink -I /build/source/llvm/tools/llvm-jitlink -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1668078801 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-11-10-135928-647445-1 -x c++ /build/source/llvm/tools/llvm-jitlink/llvm-jitlink.cpp

/build/source/llvm/tools/llvm-jitlink/llvm-jitlink.cpp

→

1//===- llvm-jitlink.cpp -- Command line interface/tester for llvm-jitlink -===//
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 utility provides a simple command line interface to the llvm jitlink
10// library, which makes relocatable object files executable in memory. Its
11// primary function is as a testing utility for the jitlink library.
12//
13//===----------------------------------------------------------------------===//

15#include "llvm-jitlink.h"

17#include "llvm/BinaryFormat/Magic.h"
18#include "llvm/ExecutionEngine/Orc/COFFPlatform.h"
19#include "llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h"
20#include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
21#include "llvm/ExecutionEngine/Orc/DebuggerSupportPlugin.h"
22#include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h"
23#include "llvm/ExecutionEngine/Orc/EPCDebugObjectRegistrar.h"
24#include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
25#include "llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h"
26#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
27#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
28#include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
29#include "llvm/ExecutionEngine/Orc/MapperJITLinkMemoryManager.h"
30#include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h"
31#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
32#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
33#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
34#include "llvm/MC/MCAsmInfo.h"
35#include "llvm/MC/MCContext.h"
36#include "llvm/MC/MCDisassembler/MCDisassembler.h"
37#include "llvm/MC/MCInstPrinter.h"
38#include "llvm/MC/MCInstrAnalysis.h"
39#include "llvm/MC/MCInstrInfo.h"
40#include "llvm/MC/MCRegisterInfo.h"
41#include "llvm/MC/MCSubtargetInfo.h"
42#include "llvm/MC/MCTargetOptions.h"
43#include "llvm/MC/TargetRegistry.h"
44#include "llvm/Object/COFF.h"
45#include "llvm/Object/MachO.h"
46#include "llvm/Object/ObjectFile.h"
47#include "llvm/Support/CommandLine.h"
48#include "llvm/Support/Debug.h"
49#include "llvm/Support/InitLLVM.h"
50#include "llvm/Support/MemoryBuffer.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/Process.h"
53#include "llvm/Support/TargetSelect.h"
54#include "llvm/Support/Timer.h"

56#include <cstring>
57#include <deque>
58#include <list>
59#include <string>

61#ifdef LLVM_ON_UNIX1
62#include <netdb.h>
63#include <netinet/in.h>
64#include <sys/socket.h>
65#include <unistd.h>
66#endif // LLVM_ON_UNIX

68#define DEBUG_TYPE"llvm_jitlink" "llvm_jitlink"

70using namespace llvm;
71using namespace llvm::jitlink;
72using namespace llvm::orc;

74static cl::OptionCategory JITLinkCategory("JITLink Options");

76static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
                                      cl::desc("input files"),
                                      cl::cat(JITLinkCategory));

80static cl::list<std::string>
  LibrarySearchPaths("L",
                     cl::desc("Add dir to the list of library search paths"),
                     cl::Prefix, cl::cat(JITLinkCategory));

85static cl::list<std::string>
  Libraries("l",
            cl::desc("Link against library X in the library search paths"),
            cl::Prefix, cl::cat(JITLinkCategory));

90static cl::list<std::string>
  LibrariesHidden("hidden-l",
                  cl::desc("Link against library X in the library search "
                           "paths with hidden visibility"),
                  cl::Prefix, cl::cat(JITLinkCategory));

96static cl::list<std::string>
  LoadHidden("load_hidden",
             cl::desc("Link against library X with hidden visibility"),
             cl::cat(JITLinkCategory));

101static cl::opt<bool> SearchSystemLibrary(
  "search-sys-lib",
  cl::desc("Add system library paths to library search paths"),
  cl::init(false), cl::cat(JITLinkCategory));

106static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"),
                          cl::init(false), cl::cat(JITLinkCategory));

109static cl::list<std::string>
  CheckFiles("check", cl::desc("File containing verifier checks"),
             cl::cat(JITLinkCategory));

113static cl::opt<std::string>
  CheckName("check-name", cl::desc("Name of checks to match against"),
            cl::init("jitlink-check"), cl::cat(JITLinkCategory));

117static cl::opt<std::string>
  EntryPointName("entry", cl::desc("Symbol to call as main entry point"),
                 cl::init(""), cl::cat(JITLinkCategory));

121static cl::list<std::string> JITDylibs(
  "jd",
  cl::desc("Specifies the JITDylib to be used for any subsequent "
           "input file, -L<seacrh-path>, and -l<library> arguments"),
  cl::cat(JITLinkCategory));

127static cl::list<std::string>
  Dylibs("preload",
         cl::desc("Pre-load dynamic libraries (e.g. language runtimes "
                  "required by the ORC runtime)"),
         cl::cat(JITLinkCategory));

133static cl::list<std::string> InputArgv("args", cl::Positional,
                                     cl::desc("<program arguments>..."),
                                     cl::PositionalEatsArgs,
                                     cl::cat(JITLinkCategory));

138static cl::opt<bool>
  DebuggerSupport("debugger-support",
                  cl::desc("Enable debugger suppport (default = !-noexec)"),
                  cl::init(true), cl::Hidden, cl::cat(JITLinkCategory));

143static cl::opt<bool>
  NoProcessSymbols("no-process-syms",
                   cl::desc("Do not resolve to llvm-jitlink process symbols"),
                   cl::init(false), cl::cat(JITLinkCategory));

148static cl::list<std::string> AbsoluteDefs(
  "abs",
  cl::desc("Inject absolute symbol definitions (syntax: <name>=<addr>)"),
  cl::cat(JITLinkCategory));

153static cl::list<std::string>
  Aliases("alias", cl::desc("Inject symbol aliases (syntax: <name>=<addr>)"),
          cl::cat(JITLinkCategory));

157static cl::list<std::string> TestHarnesses("harness", cl::Positional,
                                         cl::desc("Test harness files"),
                                         cl::PositionalEatsArgs,
                                         cl::cat(JITLinkCategory));

162static cl::opt<bool> ShowInitialExecutionSessionState(
  "show-init-es",
  cl::desc("Print ExecutionSession state before resolving entry point"),
  cl::init(false), cl::cat(JITLinkCategory));

167static cl::opt<bool> ShowEntryExecutionSessionState(
  "show-entry-es",
  cl::desc("Print ExecutionSession state after resolving entry point"),
  cl::init(false), cl::cat(JITLinkCategory));

172static cl::opt<bool> ShowAddrs(
  "show-addrs",
  cl::desc("Print registered symbol, section, got and stub addresses"),
  cl::init(false), cl::cat(JITLinkCategory));

177static cl::opt<bool> ShowLinkGraph(
  "show-graph",
  cl::desc("Print the link graph after fixups have been applied"),
  cl::init(false), cl::cat(JITLinkCategory));

182static cl::opt<bool> ShowSizes(
  "show-sizes",
  cl::desc("Show sizes pre- and post-dead stripping, and allocations"),
  cl::init(false), cl::cat(JITLinkCategory));

187static cl::opt<bool> ShowTimes("show-times",
                             cl::desc("Show times for llvm-jitlink phases"),
                             cl::init(false), cl::cat(JITLinkCategory));

191static cl::opt<std::string> SlabAllocateSizeString(
  "slab-allocate",
  cl::desc("Allocate from a slab of the given size "
           "(allowable suffixes: Kb, Mb, Gb. default = "
           "Kb)"),
  cl::init(""), cl::cat(JITLinkCategory));

198static cl::opt<uint64_t> SlabAddress(
  "slab-address",
  cl::desc("Set slab target address (requires -slab-allocate and -noexec)"),
  cl::init(~0ULL), cl::cat(JITLinkCategory));

203static cl::opt<uint64_t> SlabPageSize(
  "slab-page-size",
  cl::desc("Set page size for slab (requires -slab-allocate and -noexec)"),
  cl::init(0), cl::cat(JITLinkCategory));

208static cl::opt<bool> ShowRelocatedSectionContents(
  "show-relocated-section-contents",
  cl::desc("show section contents after fixups have been applied"),
  cl::init(false), cl::cat(JITLinkCategory));

213static cl::opt<bool> PhonyExternals(
  "phony-externals",
  cl::desc("resolve all otherwise unresolved externals to null"),
  cl::init(false), cl::cat(JITLinkCategory));

218static cl::opt<std::string> OutOfProcessExecutor(
  "oop-executor", cl::desc("Launch an out-of-process executor to run code"),
  cl::ValueOptional, cl::cat(JITLinkCategory));

222static cl::opt<std::string> OutOfProcessExecutorConnect(
  "oop-executor-connect",
  cl::desc("Connect to an out-of-process executor via TCP"),
  cl::cat(JITLinkCategory));

227static cl::opt<std::string>
  OrcRuntime("orc-runtime", cl::desc("Use ORC runtime from given path"),
             cl::init(""), cl::cat(JITLinkCategory));

231static cl::opt<bool> AddSelfRelocations(
  "add-self-relocations",
  cl::desc("Add relocations to function pointers to the current function"),
  cl::init(false), cl::cat(JITLinkCategory));

236static cl::opt<bool>
  ShowErrFailedToMaterialize("show-err-failed-to-materialize",
                             cl::desc("Show FailedToMaterialize errors"),
                             cl::init(false), cl::cat(JITLinkCategory));

241static cl::opt<bool> UseSharedMemory(
  "use-shared-memory",
  cl::desc("Use shared memory to transfer generated code and data"),
  cl::init(false), cl::cat(JITLinkCategory));

246static ExitOnError ExitOnErr;

248static LLVM_ATTRIBUTE_USED__attribute__((__used__)) void linkComponents() {
errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
       << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
       << (void *)&llvm_orc_registerJITLoaderGDBWrapper
       << (void *)&llvm_orc_registerJITLoaderGDBAllocAction;
253}

255static bool UseTestResultOverride = false;
256static int64_t TestResultOverride = 0;

258extern "C" LLVM_ATTRIBUTE_USED__attribute__((__used__)) void
259llvm_jitlink_setTestResultOverride(int64_t Value) {
TestResultOverride = Value;
UseTestResultOverride = true;
262}

264static Error addSelfRelocations(LinkGraph &G);

266namespace {

268template <typename ErrT>

270class ConditionalPrintErr {
271public:
ConditionalPrintErr(bool C) : C(C) {}
void operator()(ErrT &EI) {
  if (C) {
    errs() << "llvm-jitlink error: ";
    EI.log(errs());
    errs() << "\n";
  }
}

281private:
bool C;
283};

285Expected<std::unique_ptr<MemoryBuffer>> getFile(const Twine &FileName) {
if (auto F = MemoryBuffer::getFile(FileName))
  return std::move(*F);
else
  return createFileError(FileName, F.getError());
290}

292void reportLLVMJITLinkError(Error Err) {
handleAllErrors(
    std::move(Err),
    ConditionalPrintErr<orc::FailedToMaterialize>(ShowErrFailedToMaterialize),
    ConditionalPrintErr<ErrorInfoBase>(true));
297}

299} // end anonymous namespace

301namespace llvm {

303static raw_ostream &
304operator<<(raw_ostream &OS, const Session::MemoryRegionInfo &MRI) {
return OS << "target addr = "
          << format("0x%016" PRIx64"l" "x", MRI.getTargetAddress())
          << ", content: " << (const void *)MRI.getContent().data() << " -- "
          << (const void *)(MRI.getContent().data() + MRI.getContent().size())
          << " (" << MRI.getContent().size() << " bytes)";
310}

312static raw_ostream &
313operator<<(raw_ostream &OS, const Session::SymbolInfoMap &SIM) {
OS << "Symbols:\n";
for (auto &SKV : SIM)
  OS << "  \"" << SKV.first() << "\" " << SKV.second << "\n";
return OS;
318}

320static raw_ostream &
321operator<<(raw_ostream &OS, const Session::FileInfo &FI) {
for (auto &SIKV : FI.SectionInfos)
  OS << "  Section \"" << SIKV.first() << "\": " << SIKV.second << "\n";
for (auto &GOTKV : FI.GOTEntryInfos)
  OS << "  GOT \"" << GOTKV.first() << "\": " << GOTKV.second << "\n";
for (auto &StubKV : FI.StubInfos)
  OS << "  Stub \"" << StubKV.first() << "\": " << StubKV.second << "\n";
return OS;
329}

331static raw_ostream &
332operator<<(raw_ostream &OS, const Session::FileInfoMap &FIM) {
for (auto &FIKV : FIM)
  OS << "File \"" << FIKV.first() << "\":\n" << FIKV.second;
return OS;
336}

338static Error applyHarnessPromotions(Session &S, LinkGraph &G) {

// If this graph is part of the test harness there's nothing to do.
if (S.HarnessFiles.empty() || S.HarnessFiles.count(G.getName()))
  return Error::success();

LLVM_DEBUG(dbgs() << "Applying promotions to graph " << G.getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Applying promotions to graph "
 << G.getName() << "\n"; } } while (false);

// If this graph is part of the test then promote any symbols referenced by
// the harness to default scope, remove all symbols that clash with harness
// definitions.
std::vector<Symbol *> DefinitionsToRemove;
for (auto *Sym : G.defined_symbols()) {

  if (!Sym->hasName())
    continue;

  if (Sym->getLinkage() == Linkage::Weak) {
    if (!S.CanonicalWeakDefs.count(Sym->getName()) ||
        S.CanonicalWeakDefs[Sym->getName()] != G.getName()) {
      LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Externalizing weak symbol "
 << Sym->getName() << "\n"; }; } } while (false
)
        dbgs() << "  Externalizing weak symbol " << Sym->getName() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Externalizing weak symbol "
 << Sym->getName() << "\n"; }; } } while (false
)
      })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Externalizing weak symbol "
 << Sym->getName() << "\n"; }; } } while (false
);
      DefinitionsToRemove.push_back(Sym);
    } else {
      LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Making weak symbol "
 << Sym->getName() << " strong\n"; }; } } while
 (false)
        dbgs() << "  Making weak symbol " << Sym->getName() << " strong\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Making weak symbol "
 << Sym->getName() << " strong\n"; }; } } while
 (false)
      })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "  Making weak symbol "
 << Sym->getName() << " strong\n"; }; } } while
 (false);
      if (S.HarnessExternals.count(Sym->getName()))
        Sym->setScope(Scope::Default);
      else
        Sym->setScope(Scope::Hidden);
      Sym->setLinkage(Linkage::Strong);
    }
  } else if (S.HarnessExternals.count(Sym->getName())) {
    LLVM_DEBUG(dbgs() << "  Promoting " << Sym->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  Promoting " << Sym
->getName() << "\n"; } } while (false);
    Sym->setScope(Scope::Default);
    Sym->setLive(true);
    continue;
  } else if (S.HarnessDefinitions.count(Sym->getName())) {
    LLVM_DEBUG(dbgs() << "  Externalizing " << Sym->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  Externalizing " <<
 Sym->getName() << "\n"; } } while (false);
    DefinitionsToRemove.push_back(Sym);
  }
}

for (auto *Sym : DefinitionsToRemove)
  G.makeExternal(*Sym);

return Error::success();
387}

389static uint64_t computeTotalBlockSizes(LinkGraph &G) {
uint64_t TotalSize = 0;
for (auto *B : G.blocks())
  TotalSize += B->getSize();
return TotalSize;
394}

396static void dumpSectionContents(raw_ostream &OS, LinkGraph &G) {
constexpr orc::ExecutorAddrDiff DumpWidth = 16;
static_assert(isPowerOf2_64(DumpWidth), "DumpWidth must be a power of two");

// Put sections in address order.
std::vector<Section *> Sections;
for (auto &S : G.sections())
  Sections.push_back(&S);

llvm::sort(Sections, [](const Section *LHS, const Section *RHS) {
  if (LHS->symbols().empty() && RHS->symbols().empty())
    return false;
  if (LHS->symbols().empty())
    return false;
  if (RHS->symbols().empty())
    return true;
  SectionRange LHSRange(*LHS);
  SectionRange RHSRange(*RHS);
  return LHSRange.getStart() < RHSRange.getStart();
});

for (auto *S : Sections) {
  OS << S->getName() << " content:";
  if (S->symbols().empty()) {
    OS << "\n  section empty\n";
    continue;
  }

  // Sort symbols into order, then render.
  std::vector<Symbol *> Syms(S->symbols().begin(), S->symbols().end());
  llvm::sort(Syms, [](const Symbol *LHS, const Symbol *RHS) {
    return LHS->getAddress() < RHS->getAddress();
  });

  orc::ExecutorAddr NextAddr(Syms.front()->getAddress().getValue() &
                             ~(DumpWidth - 1));
  for (auto *Sym : Syms) {
    bool IsZeroFill = Sym->getBlock().isZeroFill();
    auto SymStart = Sym->getAddress();
    auto SymSize = Sym->getSize();
    auto SymEnd = SymStart + SymSize;
    const uint8_t *SymData = IsZeroFill ? nullptr
                                        : reinterpret_cast<const uint8_t *>(
                                              Sym->getSymbolContent().data());

    // Pad any space before the symbol starts.
    while (NextAddr != SymStart) {
      if (NextAddr % DumpWidth == 0)
        OS << formatv("\n{0:x16}:", NextAddr);
      OS << "   ";
      ++NextAddr;
    }

    // Render the symbol content.
    while (NextAddr != SymEnd) {
      if (NextAddr % DumpWidth == 0)
        OS << formatv("\n{0:x16}:", NextAddr);
      if (IsZeroFill)
        OS << " 00";
      else
        OS << formatv(" {0:x-2}", SymData[NextAddr - SymStart]);
      ++NextAddr;
    }
  }
  OS << "\n";
}
462}

464// A memory mapper with a fake offset applied only used for -noexec testing
465class InProcessDeltaMapper final : public InProcessMemoryMapper {
466public:
InProcessDeltaMapper(size_t PageSize, uint64_t TargetAddr)
    : InProcessMemoryMapper(PageSize), TargetMapAddr(TargetAddr),
      DeltaAddr(0) {}

static Expected<std::unique_ptr<InProcessDeltaMapper>> Create() {
  size_t PageSize = SlabPageSize;
  if (!PageSize) {
    if (auto PageSizeOrErr = sys::Process::getPageSize())
      PageSize = *PageSizeOrErr;
    else
      return PageSizeOrErr.takeError();
  }

  if (PageSize == 0)
    return make_error<StringError>("Page size is zero",
                                   inconvertibleErrorCode());

  return std::make_unique<InProcessDeltaMapper>(PageSize, SlabAddress);
}

void reserve(size_t NumBytes, OnReservedFunction OnReserved) override {
  InProcessMemoryMapper::reserve(
      NumBytes, [this, OnReserved = std::move(OnReserved)](
                    Expected<ExecutorAddrRange> Result) mutable {
        if (!Result)
          return OnReserved(Result.takeError());

        assert(DeltaAddr == 0 && "Overwriting previous offset")(static_cast <bool> (DeltaAddr == 0 && "Overwriting previous offset"
) ? void (0) : __assert_fail ("DeltaAddr == 0 && \"Overwriting previous offset\""
, "llvm/tools/llvm-jitlink/llvm-jitlink.cpp", 494, __extension__
 __PRETTY_FUNCTION__));
        if (TargetMapAddr != ~0ULL)
          DeltaAddr = TargetMapAddr - Result->Start.getValue();
        auto OffsetRange = ExecutorAddrRange(Result->Start + DeltaAddr,
                                             Result->End + DeltaAddr);

        OnReserved(OffsetRange);
      });
}

char *prepare(ExecutorAddr Addr, size_t ContentSize) override {
  return InProcessMemoryMapper::prepare(Addr - DeltaAddr, ContentSize);
}

void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override {
  // Slide mapping based on delta and make all segments read-writable.
  auto FixedAI = AI;
  FixedAI.MappingBase -= DeltaAddr;
  for (auto &Seg : FixedAI.Segments)
    Seg.AG = AllocGroup(MemProt::Read | MemProt::Write,
                        Seg.AG.getMemDeallocPolicy());
  InProcessMemoryMapper::initialize(
      FixedAI, [this, OnInitialized = std::move(OnInitialized)](
                   Expected<ExecutorAddr> Result) mutable {
        if (!Result)
          return OnInitialized(Result.takeError());

        OnInitialized(ExecutorAddr(Result->getValue() + DeltaAddr));
      });
}

void deinitialize(ArrayRef<ExecutorAddr> Allocations,
                  OnDeinitializedFunction OnDeInitialized) override {
  std::vector<ExecutorAddr> Addrs(Allocations.size());
  for (const auto Base : Allocations) {
    Addrs.push_back(Base - DeltaAddr);
  }

  InProcessMemoryMapper::deinitialize(Addrs, std::move(OnDeInitialized));
}

void release(ArrayRef<ExecutorAddr> Reservations,
             OnReleasedFunction OnRelease) override {
  std::vector<ExecutorAddr> Addrs(Reservations.size());
  for (const auto Base : Reservations) {
    Addrs.push_back(Base - DeltaAddr);
  }
  InProcessMemoryMapper::release(Addrs, std::move(OnRelease));
}

544private:
uint64_t TargetMapAddr;
uint64_t DeltaAddr;
547};

549Expected<uint64_t> getSlabAllocSize(StringRef SizeString) {
SizeString = SizeString.trim();

uint64_t Units = 1024;

if (SizeString.endswith_insensitive("kb"))
  SizeString = SizeString.drop_back(2).rtrim();
else if (SizeString.endswith_insensitive("mb")) {
  Units = 1024 * 1024;
  SizeString = SizeString.drop_back(2).rtrim();
} else if (SizeString.endswith_insensitive("gb")) {
  Units = 1024 * 1024 * 1024;
  SizeString = SizeString.drop_back(2).rtrim();
}

uint64_t SlabSize = 0;
if (SizeString.getAsInteger(10, SlabSize))
  return make_error<StringError>("Invalid numeric format for slab size",
                                 inconvertibleErrorCode());

return SlabSize * Units;
570}

572static std::unique_ptr<JITLinkMemoryManager> createInProcessMemoryManager() {
uint64_t SlabSize;
574#ifdef _WIN32
SlabSize = 1024 * 1024;
576#else
SlabSize = 1024 * 1024 * 1024;
578#endif

if (!SlabAllocateSizeString.empty())
  SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString));

// If this is a -no-exec case and we're tweaking the slab address or size then
// use the delta mapper.
if (NoExec && (SlabAddress || SlabPageSize))
  return ExitOnErr(
      MapperJITLinkMemoryManager::CreateWithMapper<InProcessDeltaMapper>(
          SlabSize));

// Otherwise use the standard in-process mapper.
return ExitOnErr(
    MapperJITLinkMemoryManager::CreateWithMapper<InProcessMemoryMapper>(
        SlabSize));
594}

596Expected<std::unique_ptr<jitlink::JITLinkMemoryManager>>
597createSharedMemoryManager(SimpleRemoteEPC &SREPC) {
SharedMemoryMapper::SymbolAddrs SAs;
if (auto Err = SREPC.getBootstrapSymbols(
        {{SAs.Instance, rt::ExecutorSharedMemoryMapperServiceInstanceName},
         {SAs.Reserve,
          rt::ExecutorSharedMemoryMapperServiceReserveWrapperName},
         {SAs.Initialize,
          rt::ExecutorSharedMemoryMapperServiceInitializeWrapperName},
         {SAs.Deinitialize,
          rt::ExecutorSharedMemoryMapperServiceDeinitializeWrapperName},
         {SAs.Release,
          rt::ExecutorSharedMemoryMapperServiceReleaseWrapperName}}))
  return std::move(Err);

611#ifdef _WIN32
size_t SlabSize = 1024 * 1024;
613#else
size_t SlabSize = 1024 * 1024 * 1024;
615#endif

if (!SlabAllocateSizeString.empty())
  SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString));

return MapperJITLinkMemoryManager::CreateWithMapper<SharedMemoryMapper>(
    SlabSize, SREPC, SAs);
622}


625static Expected<MaterializationUnit::Interface>
626getTestObjectFileInterface(Session &S, MemoryBufferRef O) {

// Get the standard interface for this object, but ignore the symbols field.
// We'll handle that manually to include promotion.
auto I = getObjectFileInterface(S.ES, O);
if (!I)
  return I.takeError();
I->SymbolFlags.clear();

// If creating an object file was going to fail it would have happened above,
// so we can 'cantFail' this.
auto Obj = cantFail(object::ObjectFile::createObjectFile(O));

// The init symbol must be included in the SymbolFlags map if present.
if (I->InitSymbol)
  I->SymbolFlags[I->InitSymbol] =
      JITSymbolFlags::MaterializationSideEffectsOnly;

for (auto &Sym : Obj->symbols()) {
  Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
  if (!SymFlagsOrErr)
    // TODO: Test this error.
    return SymFlagsOrErr.takeError();

  // Skip symbols not defined in this object file.
  if ((*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined))
    continue;

  auto Name = Sym.getName();
  if (!Name)
    return Name.takeError();

  // Skip symbols that have type SF_File.
  if (auto SymType = Sym.getType()) {
    if (*SymType == object::SymbolRef::ST_File)
      continue;
  } else
    return SymType.takeError();

  auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
  if (!SymFlags)
    return SymFlags.takeError();

  if (SymFlags->isWeak()) {
    // If this is a weak symbol that's not defined in the harness then we
    // need to either mark it as strong (if this is the first definition
    // that we've seen) or discard it.
    if (S.HarnessDefinitions.count(*Name) || S.CanonicalWeakDefs.count(*Name))
      continue;
    S.CanonicalWeakDefs[*Name] = O.getBufferIdentifier();
    *SymFlags &= ~JITSymbolFlags::Weak;
    if (!S.HarnessExternals.count(*Name))
      *SymFlags &= ~JITSymbolFlags::Exported;
  } else if (S.HarnessExternals.count(*Name)) {
    *SymFlags |= JITSymbolFlags::Exported;
  } else if (S.HarnessDefinitions.count(*Name) ||
             !(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global))
    continue;

  auto InternedName = S.ES.intern(*Name);
  I->SymbolFlags[InternedName] = std::move(*SymFlags);
}

return I;
690}

692static Error loadProcessSymbols(Session &S) {
auto FilterMainEntryPoint =
    [EPName = S.ES.intern(EntryPointName)](SymbolStringPtr Name) {
      return Name != EPName;
    };
S.MainJD->addGenerator(
    ExitOnErr(orc::EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
        S.ES, std::move(FilterMainEntryPoint))));

return Error::success();
702}

704static Error loadDylibs(Session &S) {
LLVM_DEBUG(dbgs() << "Loading dylibs...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Loading dylibs...\n"; } }
 while (false);
for (const auto &Dylib : Dylibs) {
  LLVM_DEBUG(dbgs() << "  " << Dylib << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  " << Dylib <<
 "\n"; } } while (false);
  if (auto Err = S.loadAndLinkDynamicLibrary(*S.MainJD, Dylib))
    return Err;
}

return Error::success();
713}

715static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() {
716#ifndef LLVM_ON_UNIX1
// FIXME: Add support for Windows.
return make_error<StringError>("-" + OutOfProcessExecutor.ArgStr +
                                   " not supported on non-unix platforms",
                               inconvertibleErrorCode());
721#elif !LLVM_ENABLE_THREADS1
// Out of process mode using SimpleRemoteEPC depends on threads.
return make_error<StringError>(
    "-" + OutOfProcessExecutor.ArgStr +
        " requires threads, but LLVM was built with "
        "LLVM_ENABLE_THREADS=Off",
    inconvertibleErrorCode());
728#else

constexpr int ReadEnd = 0;
constexpr int WriteEnd = 1;

// Pipe FDs.
int ToExecutor[2];
int FromExecutor[2];

pid_t ChildPID;

// Create pipes to/from the executor..
if (pipe(ToExecutor) != 0 || pipe(FromExecutor) != 0)
  return make_error<StringError>("Unable to create pipe for executor",
                                 inconvertibleErrorCode());

ChildPID = fork();

if (ChildPID == 0) {
  // In the child...

  // Close the parent ends of the pipes
  close(ToExecutor[WriteEnd]);
  close(FromExecutor[ReadEnd]);

  // Execute the child process.
  std::unique_ptr<char[]> ExecutorPath, FDSpecifier;
  {
    ExecutorPath = std::make_unique<char[]>(OutOfProcessExecutor.size() + 1);
    strcpy(ExecutorPath.get(), OutOfProcessExecutor.data());

    std::string FDSpecifierStr("filedescs=");
    FDSpecifierStr += utostr(ToExecutor[ReadEnd]);
    FDSpecifierStr += ',';
    FDSpecifierStr += utostr(FromExecutor[WriteEnd]);
    FDSpecifier = std::make_unique<char[]>(FDSpecifierStr.size() + 1);
    strcpy(FDSpecifier.get(), FDSpecifierStr.c_str());
  }

  char *const Args[] = {ExecutorPath.get(), FDSpecifier.get(), nullptr};
  int RC = execvp(ExecutorPath.get(), Args);
  if (RC != 0) {
    errs() << "unable to launch out-of-process executor \""
           << ExecutorPath.get() << "\"\n";
    exit(1);
  }
}
// else we're the parent...

// Close the child ends of the pipes
close(ToExecutor[ReadEnd]);
close(FromExecutor[WriteEnd]);

auto S = SimpleRemoteEPC::Setup();
if (UseSharedMemory)
  S.CreateMemoryManager = createSharedMemoryManager;

return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
    std::make_unique<DynamicThreadPoolTaskDispatcher>(), std::move(S),
    FromExecutor[ReadEnd], ToExecutor[WriteEnd]);
788#endif
789}

791#if LLVM_ON_UNIX1 && LLVM_ENABLE_THREADS1
792static Error createTCPSocketError(Twine Details) {
return make_error<StringError>(
    formatv("Failed to connect TCP socket '{0}': {1}",
            OutOfProcessExecutorConnect, Details),
    inconvertibleErrorCode());
797}

799static Expected<int> connectTCPSocket(std::string Host, std::string PortStr) {
addrinfo *AI;
addrinfo Hints{};
Hints.ai_family = AF_INET2;
Hints.ai_socktype = SOCK_STREAMSOCK_STREAM;
Hints.ai_flags = AI_NUMERICSERV0x0400;

if (int EC = getaddrinfo(Host.c_str(), PortStr.c_str(), &Hints, &AI))
  return createTCPSocketError("Address resolution failed (" +
                              StringRef(gai_strerror(EC)) + ")");

// Cycle through the returned addrinfo structures and connect to the first
// reachable endpoint.
int SockFD;
addrinfo *Server;
for (Server = AI; Server != nullptr; Server = Server->ai_next) {
  // socket might fail, e.g. if the address family is not supported. Skip to
  // the next addrinfo structure in such a case.
  if ((SockFD = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol)) < 0)
    continue;

  // If connect returns null, we exit the loop with a working socket.
  if (connect(SockFD, Server->ai_addr, Server->ai_addrlen) == 0)
    break;

  close(SockFD);
}
freeaddrinfo(AI);

// If we reached the end of the loop without connecting to a valid endpoint,
// dump the last error that was logged in socket() or connect().
if (Server == nullptr)
  return createTCPSocketError(std::strerror(errno(*__errno_location ())));

return SockFD;
834}
835#endif

837static Expected<std::unique_ptr<ExecutorProcessControl>> connectToExecutor() {
838#ifndef LLVM_ON_UNIX1
// FIXME: Add TCP support for Windows.
return make_error<StringError>("-" + OutOfProcessExecutorConnect.ArgStr +
                                   " not supported on non-unix platforms",
                               inconvertibleErrorCode());
843#elif !LLVM_ENABLE_THREADS1
// Out of process mode using SimpleRemoteEPC depends on threads.
return make_error<StringError>(
    "-" + OutOfProcessExecutorConnect.ArgStr +
        " requires threads, but LLVM was built with "
        "LLVM_ENABLE_THREADS=Off",
    inconvertibleErrorCode());
850#else

StringRef Host, PortStr;
std::tie(Host, PortStr) = StringRef(OutOfProcessExecutorConnect).split(':');
if (Host.empty())
  return createTCPSocketError("Host name for -" +
                              OutOfProcessExecutorConnect.ArgStr +
                              " can not be empty");
if (PortStr.empty())
  return createTCPSocketError("Port number in -" +
                              OutOfProcessExecutorConnect.ArgStr +
                              " can not be empty");
int Port = 0;
if (PortStr.getAsInteger(10, Port))
  return createTCPSocketError("Port number '" + PortStr +
                              "' is not a valid integer");

Expected<int> SockFD = connectTCPSocket(Host.str(), PortStr.str());
if (!SockFD)
  return SockFD.takeError();

auto S = SimpleRemoteEPC::Setup();
if (UseSharedMemory)
  S.CreateMemoryManager = createSharedMemoryManager;

return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
    std::make_unique<DynamicThreadPoolTaskDispatcher>(),
    std::move(S), *SockFD, *SockFD);
878#endif
879}

881class PhonyExternalsGenerator : public DefinitionGenerator {
882public:
Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                    JITDylibLookupFlags JDLookupFlags,
                    const SymbolLookupSet &LookupSet) override {
  SymbolMap PhonySymbols;
  for (auto &KV : LookupSet)
    PhonySymbols[KV.first] = JITEvaluatedSymbol(0, JITSymbolFlags::Exported);
  return JD.define(absoluteSymbols(std::move(PhonySymbols)));
}
891};

893Expected<std::unique_ptr<Session>> Session::Create(Triple TT) {

std::unique_ptr<ExecutorProcessControl> EPC;
if (OutOfProcessExecutor.getNumOccurrences()) {
  /// If -oop-executor is passed then launch the executor.
  if (auto REPC = launchExecutor())
    EPC = std::move(*REPC);
  else
    return REPC.takeError();
} else if (OutOfProcessExecutorConnect.getNumOccurrences()) {
  /// If -oop-executor-connect is passed then connect to the executor.
  if (auto REPC = connectToExecutor())
    EPC = std::move(*REPC);
  else
    return REPC.takeError();
} else {
  /// Otherwise use SelfExecutorProcessControl to target the current process.
  auto PageSize = sys::Process::getPageSize();
  if (!PageSize)
    return PageSize.takeError();
  EPC = std::make_unique<SelfExecutorProcessControl>(
      std::make_shared<SymbolStringPool>(),
      std::make_unique<InPlaceTaskDispatcher>(), std::move(TT), *PageSize,
      createInProcessMemoryManager());
}

Error Err = Error::success();
std::unique_ptr<Session> S(new Session(std::move(EPC), Err));
if (Err)
  return std::move(Err);
return std::move(S);
924}

926Session::~Session() {
if (auto Err = ES.endSession())
  ES.reportError(std::move(Err));
929}

931Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
  : ES(std::move(EPC)),
    ObjLayer(ES, ES.getExecutorProcessControl().getMemMgr()) {

/// Local ObjectLinkingLayer::Plugin class to forward modifyPassConfig to the
/// Session.
class JITLinkSessionPlugin : public ObjectLinkingLayer::Plugin {
public:
  JITLinkSessionPlugin(Session &S) : S(S) {}
  void modifyPassConfig(MaterializationResponsibility &MR, LinkGraph &G,
                        PassConfiguration &PassConfig) override {
    S.modifyPassConfig(G.getTargetTriple(), PassConfig);
  }

  Error notifyFailed(MaterializationResponsibility &MR) override {
    return Error::success();
  }
  Error notifyRemovingResources(ResourceKey K) override {
    return Error::success();
  }
  void notifyTransferringResources(ResourceKey DstKey,
                                   ResourceKey SrcKey) override {}

private:
  Session &S;
};

ErrorAsOutParameter _(&Err);

ES.setErrorReporter(reportLLVMJITLinkError);

if (auto MainJDOrErr = ES.createJITDylib("main"))
  MainJD = &*MainJDOrErr;
else {
  Err = MainJDOrErr.takeError();
  return;
}

if (!NoProcessSymbols)
  ExitOnErr(loadProcessSymbols(*this));
else {
  // This symbol is used in testcases.
  auto &TestResultJD = ES.createBareJITDylib("<TestResultJD>");
  ExitOnErr(TestResultJD.define(absoluteSymbols(
      {{ES.intern("llvm_jitlink_setTestResultOverride"),
        {pointerToJITTargetAddress(llvm_jitlink_setTestResultOverride),
         JITSymbolFlags::Exported}}})));
  MainJD->addToLinkOrder(TestResultJD);
}

ExitOnErr(loadDylibs(*this));

auto &TT = ES.getExecutorProcessControl().getTargetTriple();

if (DebuggerSupport && TT.isOSBinFormatMachO())
  ObjLayer.addPlugin(ExitOnErr(
      GDBJITDebugInfoRegistrationPlugin::Create(this->ES, *MainJD, TT)));

// Set up the platform.
if (TT.isOSBinFormatMachO() && !OrcRuntime.empty()) {
  if (auto P =
          MachOPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
    ES.setPlatform(std::move(*P));
  else {
    Err = P.takeError();
    return;
  }
} else if (TT.isOSBinFormatELF() && !OrcRuntime.empty()) {
  if (auto P =
          ELFNixPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
    ES.setPlatform(std::move(*P));
  else {
    Err = P.takeError();
    return;
  }
} else if (TT.isOSBinFormatCOFF() && !OrcRuntime.empty()) {
  auto LoadDynLibrary = [&, this](JITDylib &JD, StringRef DLLName) -> Error {
    if (!DLLName.endswith_insensitive(".dll"))
      return make_error<StringError>("DLLName not ending with .dll",
                                     inconvertibleErrorCode());
    return loadAndLinkDynamicLibrary(JD, DLLName);
  };

  if (auto P = COFFPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str(),
                                    std::move(LoadDynLibrary))) 
    ES.setPlatform(std::move(*P));
   else {
    Err = P.takeError();
    return;
  }
} else if (TT.isOSBinFormatELF()) {
  if (!NoExec)
    ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
        ES, ExitOnErr(EPCEHFrameRegistrar::Create(this->ES))));
  if (DebuggerSupport)
    ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>(
        ES, ExitOnErr(createJITLoaderGDBRegistrar(this->ES))));
}

ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));

// Process any harness files.
for (auto &HarnessFile : TestHarnesses) {
  HarnessFiles.insert(HarnessFile);

  auto ObjBuffer = ExitOnErr(getFile(HarnessFile));

  auto ObjInterface =
      ExitOnErr(getObjectFileInterface(ES, ObjBuffer->getMemBufferRef()));

  for (auto &KV : ObjInterface.SymbolFlags)
    HarnessDefinitions.insert(*KV.first);

  auto Obj = ExitOnErr(
      object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));

  for (auto &Sym : Obj->symbols()) {
    uint32_t SymFlags = ExitOnErr(Sym.getFlags());
    auto Name = ExitOnErr(Sym.getName());

    if (Name.empty())
      continue;

    if (SymFlags & object::BasicSymbolRef::SF_Undefined)
      HarnessExternals.insert(Name);
  }
}

// If a name is defined by some harness file then it's a definition, not an
// external.
for (auto &DefName : HarnessDefinitions)
  HarnessExternals.erase(DefName.getKey());
1063}

1065void Session::dumpSessionInfo(raw_ostream &OS) {
OS << "Registered addresses:\n" << SymbolInfos << FileInfos;
1067}

1069void Session::modifyPassConfig(const Triple &TT,
                             PassConfiguration &PassConfig) {
if (!CheckFiles.empty())
  PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) {
    auto &EPC = ES.getExecutorProcessControl();
    if (EPC.getTargetTriple().getObjectFormat() == Triple::ELF)
      return registerELFGraphInfo(*this, G);

    if (EPC.getTargetTriple().getObjectFormat() == Triple::MachO)
      return registerMachOGraphInfo(*this, G);

    if (EPC.getTargetTriple().getObjectFormat() == Triple::COFF)
      return registerCOFFGraphInfo(*this, G);

    return make_error<StringError>("Unsupported object format for GOT/stub "
                                   "registration",
                                   inconvertibleErrorCode());
  });

if (ShowLinkGraph)
  PassConfig.PostFixupPasses.push_back([](LinkGraph &G) -> Error {
    outs() << "Link graph \"" << G.getName() << "\" post-fixup:\n";
    G.dump(outs());
    return Error::success();
  });

PassConfig.PrePrunePasses.push_back(
    [this](LinkGraph &G) { return applyHarnessPromotions(*this, G); });

if (ShowSizes) {
  PassConfig.PrePrunePasses.push_back([this](LinkGraph &G) -> Error {
    SizeBeforePruning += computeTotalBlockSizes(G);
    return Error::success();
  });
  PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error {
    SizeAfterFixups += computeTotalBlockSizes(G);
    return Error::success();
  });
}

if (ShowRelocatedSectionContents)
  PassConfig.PostFixupPasses.push_back([](LinkGraph &G) -> Error {
    outs() << "Relocated section contents for " << G.getName() << ":\n";
    dumpSectionContents(outs(), G);
    return Error::success();
  });

if (AddSelfRelocations)
  PassConfig.PostPrunePasses.push_back(addSelfRelocations);
1118}

1120Expected<JITDylib *> Session::getOrLoadDynamicLibrary(StringRef LibPath) {
auto It = DynLibJDs.find(LibPath.str());
if (It != DynLibJDs.end()) {
  return It->second;
}
auto G = EPCDynamicLibrarySearchGenerator::Load(ES, LibPath.data());
if (!G)
  return G.takeError();
auto JD = &ES.createBareJITDylib(LibPath.str());

JD->addGenerator(std::move(*G));
DynLibJDs.emplace(LibPath.str(), JD);
LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Loaded dynamic library "
 << LibPath.data() << " for " << LibPath <<
 "\n"; }; } } while (false)
  dbgs() << "Loaded dynamic library " << LibPath.data() << " for " << LibPathdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Loaded dynamic library "
 << LibPath.data() << " for " << LibPath <<
 "\n"; }; } } while (false)
         << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Loaded dynamic library "
 << LibPath.data() << " for " << LibPath <<
 "\n"; }; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Loaded dynamic library "
 << LibPath.data() << " for " << LibPath <<
 "\n"; }; } } while (false);
return JD;
1137}

1139Error Session::loadAndLinkDynamicLibrary(JITDylib &JD, StringRef LibPath) {
auto DL = getOrLoadDynamicLibrary(LibPath);
if (!DL)
  return DL.takeError();
JD.addToLinkOrder(**DL);
LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Linking dynamic library "
 << LibPath << " to " << JD.getName() <<
 "\n"; }; } } while (false)
  dbgs() << "Linking dynamic library " << LibPath << " to " << JD.getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Linking dynamic library "
 << LibPath << " to " << JD.getName() <<
 "\n"; }; } } while (false)
         << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Linking dynamic library "
 << LibPath << " to " << JD.getName() <<
 "\n"; }; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Linking dynamic library "
 << LibPath << " to " << JD.getName() <<
 "\n"; }; } } while (false);
return Error::success();
1149}

1151Expected<Session::FileInfo &> Session::findFileInfo(StringRef FileName) {
auto FileInfoItr = FileInfos.find(FileName);
if (FileInfoItr == FileInfos.end())
  return make_error<StringError>("file \"" + FileName + "\" not recognized",
                                 inconvertibleErrorCode());
return FileInfoItr->second;
1157}

1159Expected<Session::MemoryRegionInfo &>
1160Session::findSectionInfo(StringRef FileName, StringRef SectionName) {
auto FI = findFileInfo(FileName);
if (!FI)
  return FI.takeError();
auto SecInfoItr = FI->SectionInfos.find(SectionName);
if (SecInfoItr == FI->SectionInfos.end())
  return make_error<StringError>("no section \"" + SectionName +
                                     "\" registered for file \"" + FileName +
                                     "\"",
                                 inconvertibleErrorCode());
return SecInfoItr->second;
1171}

1173Expected<Session::MemoryRegionInfo &>
1174Session::findStubInfo(StringRef FileName, StringRef TargetName) {
auto FI = findFileInfo(FileName);
if (!FI)
  return FI.takeError();
auto StubInfoItr = FI->StubInfos.find(TargetName);
if (StubInfoItr == FI->StubInfos.end())
  return make_error<StringError>("no stub for \"" + TargetName +
                                     "\" registered for file \"" + FileName +
                                     "\"",
                                 inconvertibleErrorCode());
return StubInfoItr->second;
1185}

1187Expected<Session::MemoryRegionInfo &>
1188Session::findGOTEntryInfo(StringRef FileName, StringRef TargetName) {
auto FI = findFileInfo(FileName);
if (!FI)
  return FI.takeError();
auto GOTInfoItr = FI->GOTEntryInfos.find(TargetName);
if (GOTInfoItr == FI->GOTEntryInfos.end())
  return make_error<StringError>("no GOT entry for \"" + TargetName +
                                     "\" registered for file \"" + FileName +
                                     "\"",
                                 inconvertibleErrorCode());
return GOTInfoItr->second;
1199}

1201bool Session::isSymbolRegistered(StringRef SymbolName) {
return SymbolInfos.count(SymbolName);
1203}

1205Expected<Session::MemoryRegionInfo &>
1206Session::findSymbolInfo(StringRef SymbolName, Twine ErrorMsgStem) {
auto SymInfoItr = SymbolInfos.find(SymbolName);
if (SymInfoItr == SymbolInfos.end())
  return make_error<StringError>(ErrorMsgStem + ": symbol " + SymbolName +
                                     " not found",
                                 inconvertibleErrorCode());
return SymInfoItr->second;
1213}

1215} // end namespace llvm

1217static Triple getFirstFileTriple() {
static Triple FirstTT = []() {
  assert(!InputFiles.empty() && "InputFiles can not be empty")(static_cast <bool> (!InputFiles.empty() && "InputFiles can not be empty"
) ? void (0) : __assert_fail ("!InputFiles.empty() && \"InputFiles can not be empty\""
, "llvm/tools/llvm-jitlink/llvm-jitlink.cpp", 1219, __extension__
 __PRETTY_FUNCTION__));
  for (auto InputFile : InputFiles) {
    auto ObjBuffer = ExitOnErr(getFile(InputFile));
    file_magic Magic = identify_magic(ObjBuffer->getBuffer());
    switch (Magic) {
    case file_magic::coff_object:
    case file_magic::elf_relocatable:
    case file_magic::macho_object: {
      auto Obj = ExitOnErr(
          object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
      Triple TT = Obj->makeTriple();
      if (Magic == file_magic::coff_object) {
        // TODO: Move this to makeTriple() if possible.
        TT.setObjectFormat(Triple::COFF);
        TT.setOS(Triple::OSType::Win32);
      }
      return TT;
    }
    default:
      break;
    }
  }
  return Triple();
}();

return FirstTT;
1245}

1247static Error sanitizeArguments(const Triple &TT, const char *ArgV0) {

// -noexec and --args should not be used together.
if (NoExec && !InputArgv.empty())
  errs() << "Warning: --args passed to -noexec run will be ignored.\n";

// Set the entry point name if not specified.
if (EntryPointName.empty())
  EntryPointName = TT.getObjectFormat() == Triple::MachO ? "_main" : "main";

// Disable debugger support by default in noexec tests.
if (DebuggerSupport.getNumOccurrences() == 0 && NoExec)
  DebuggerSupport = false;

// If -slab-allocate is passed, check that we're not trying to use it in
// -oop-executor or -oop-executor-connect mode.
//
// FIXME: Remove once we enable remote slab allocation.
if (SlabAllocateSizeString != "") {
  if (OutOfProcessExecutor.getNumOccurrences() ||
      OutOfProcessExecutorConnect.getNumOccurrences())
    return make_error<StringError>(
        "-slab-allocate cannot be used with -oop-executor or "
        "-oop-executor-connect",
        inconvertibleErrorCode());
}

// If -slab-address is passed, require -slab-allocate and -noexec
if (SlabAddress != ~0ULL) {
  if (SlabAllocateSizeString == "" || !NoExec)
    return make_error<StringError>(
        "-slab-address requires -slab-allocate and -noexec",
        inconvertibleErrorCode());

  if (SlabPageSize == 0)
    errs() << "Warning: -slab-address used without -slab-page-size.\n";
}

if (SlabPageSize != 0) {
  // -slab-page-size requires slab alloc.
  if (SlabAllocateSizeString == "")
    return make_error<StringError>("-slab-page-size requires -slab-allocate",
                                   inconvertibleErrorCode());

  // Check -slab-page-size / -noexec interactions.
  if (!NoExec) {
    if (auto RealPageSize = sys::Process::getPageSize()) {
      if (SlabPageSize % *RealPageSize)
        return make_error<StringError>(
            "-slab-page-size must be a multiple of real page size for exec "
            "tests (did you mean to use -noexec ?)\n",
            inconvertibleErrorCode());
    } else {
      errs() << "Could not retrieve process page size:\n";
      logAllUnhandledErrors(RealPageSize.takeError(), errs(), "");
      errs() << "Executing with slab page size = "
             << formatv("{0:x}", SlabPageSize) << ".\n"
             << "Tool may crash if " << formatv("{0:x}", SlabPageSize)
             << " is not a multiple of the real process page size.\n"
             << "(did you mean to use -noexec ?)";
    }
  }
}

// Only one of -oop-executor and -oop-executor-connect can be used.
if (!!OutOfProcessExecutor.getNumOccurrences() &&
    !!OutOfProcessExecutorConnect.getNumOccurrences())
  return make_error<StringError>(
      "Only one of -" + OutOfProcessExecutor.ArgStr + " and -" +
          OutOfProcessExecutorConnect.ArgStr + " can be specified",
      inconvertibleErrorCode());

// If -oop-executor was used but no value was specified then use a sensible
// default.
if (!!OutOfProcessExecutor.getNumOccurrences() &&
    OutOfProcessExecutor.empty()) {
  SmallString<256> OOPExecutorPath(sys::fs::getMainExecutable(
      ArgV0, reinterpret_cast<void *>(&sanitizeArguments)));
  sys::path::remove_filename(OOPExecutorPath);
  sys::path::append(OOPExecutorPath, "llvm-jitlink-executor");
  OutOfProcessExecutor = OOPExecutorPath.str().str();
}

return Error::success();
1331}

1333static void addPhonyExternalsGenerator(Session &S) {
S.MainJD->addGenerator(std::make_unique<PhonyExternalsGenerator>());
1335}

1337static Error createJITDylibs(Session &S,
                           std::map<unsigned, JITDylib *> &IdxToJD) {
// First, set up JITDylibs.
LLVM_DEBUG(dbgs() << "Creating JITDylibs...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Creating JITDylibs...\n"
; } } while (false);
{
  // Create a "main" JITLinkDylib.
  IdxToJD[0] = S.MainJD;
  S.JDSearchOrder.push_back({S.MainJD, JITDylibLookupFlags::MatchAllSymbols});
  LLVM_DEBUG(dbgs() << "  0: " << S.MainJD->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  0: " << S.MainJD
->getName() << "\n"; } } while (false);

  // Add any extra JITDylibs from the command line.
  for (auto JDItr = JITDylibs.begin(), JDEnd = JITDylibs.end();
       JDItr != JDEnd; ++JDItr) {
    auto JD = S.ES.createJITDylib(*JDItr);
    if (!JD)
      return JD.takeError();
    unsigned JDIdx = JITDylibs.getPosition(JDItr - JITDylibs.begin());
    IdxToJD[JDIdx] = &*JD;
    S.JDSearchOrder.push_back({&*JD, JITDylibLookupFlags::MatchAllSymbols});
    LLVM_DEBUG(dbgs() << "  " << JDIdx << ": " << JD->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  " << JDIdx <<
 ": " << JD->getName() << "\n"; } } while (false
);
  }
}

LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false)
  dbgs() << "Dylib search order is [ ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false)
  for (auto &KV : S.JDSearchOrder)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false)
    dbgs() << KV.first->getName() << " ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false)
  dbgs() << "]\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Dylib search order is [ "
; for (auto &KV : S.JDSearchOrder) dbgs() << KV.first
->getName() << " "; dbgs() << "]\n"; }; } } while
 (false);

return Error::success();
1368}

1370static Error addAbsoluteSymbols(Session &S,
                              const std::map<unsigned, JITDylib *> &IdxToJD) {
// Define absolute symbols.
LLVM_DEBUG(dbgs() << "Defining absolute symbols...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Defining absolute symbols...\n"
; } } while (false);
for (auto AbsDefItr = AbsoluteDefs.begin(), AbsDefEnd = AbsoluteDefs.end();
     AbsDefItr != AbsDefEnd; ++AbsDefItr) {
  unsigned AbsDefArgIdx =
    AbsoluteDefs.getPosition(AbsDefItr - AbsoluteDefs.begin());
  auto &JD = *std::prev(IdxToJD.lower_bound(AbsDefArgIdx))->second;

  StringRef AbsDefStmt = *AbsDefItr;
  size_t EqIdx = AbsDefStmt.find_first_of('=');
  if (EqIdx == StringRef::npos)
    return make_error<StringError>("Invalid absolute define \"" + AbsDefStmt +
                                   "\". Syntax: <name>=<addr>",
                                   inconvertibleErrorCode());
  StringRef Name = AbsDefStmt.substr(0, EqIdx).trim();
  StringRef AddrStr = AbsDefStmt.substr(EqIdx + 1).trim();

  uint64_t Addr;
  if (AddrStr.getAsInteger(0, Addr))
    return make_error<StringError>("Invalid address expression \"" + AddrStr +
                                       "\" in absolute symbol definition \"" +
                                       AbsDefStmt + "\"",
                                   inconvertibleErrorCode());
  JITEvaluatedSymbol AbsDef(Addr, JITSymbolFlags::Exported);
  if (auto Err = JD.define(absoluteSymbols({{S.ES.intern(Name), AbsDef}})))
    return Err;

  // Register the absolute symbol with the session symbol infos.
  S.SymbolInfos[Name] = {ArrayRef<char>(), Addr};
}

return Error::success();
1404}

1406static Error addAliases(Session &S,
                      const std::map<unsigned, JITDylib *> &IdxToJD) {
// Define absolute symbols.
LLVM_DEBUG(dbgs() << "Defining aliases...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Defining aliases...\n"; }
 } while (false);
for (auto AliasItr = Aliases.begin(), AliasEnd = Aliases.end();
     AliasItr != AliasEnd; ++AliasItr) {
  unsigned AliasArgIdx = Aliases.getPosition(AliasItr - Aliases.begin());
  auto &JD = *std::prev(IdxToJD.lower_bound(AliasArgIdx))->second;

  StringRef AliasStmt = *AliasItr;
  size_t EqIdx = AliasStmt.find_first_of('=');
  if (EqIdx == StringRef::npos)
    return make_error<StringError>("Invalid alias definition \"" + AliasStmt +
                                       "\". Syntax: <name>=<addr>",
                                   inconvertibleErrorCode());
  StringRef Alias = AliasStmt.substr(0, EqIdx).trim();
  StringRef Aliasee = AliasStmt.substr(EqIdx + 1).trim();

  SymbolAliasMap SAM;
  SAM[S.ES.intern(Alias)] = {S.ES.intern(Aliasee), JITSymbolFlags::Exported};
  if (auto Err = JD.define(symbolAliases(std::move(SAM))))
    return Err;
}

return Error::success();
1431}

1433static Error addTestHarnesses(Session &S) {
LLVM_DEBUG(dbgs() << "Adding test harness objects...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Adding test harness objects...\n"
; } } while (false);
for (auto HarnessFile : TestHarnesses) {
  LLVM_DEBUG(dbgs() << "  " << HarnessFile << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  " << HarnessFile
 << "\n"; } } while (false);
  auto ObjBuffer = getFile(HarnessFile);
  if (!ObjBuffer)
    return ObjBuffer.takeError();
  if (auto Err = S.ObjLayer.add(*S.MainJD, std::move(*ObjBuffer)))
    return Err;
}
return Error::success();
1444}

1446static Error addObjects(Session &S,
                      const std::map<unsigned, JITDylib *> &IdxToJD) {

// Load each object into the corresponding JITDylib..
LLVM_DEBUG(dbgs() << "Adding objects...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Adding objects...\n"; } }
 while (false);
for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
     InputFileItr != InputFileEnd; ++InputFileItr) {
  unsigned InputFileArgIdx =
      InputFiles.getPosition(InputFileItr - InputFiles.begin());
  const std::string &InputFile = *InputFileItr;
  if (StringRef(InputFile).endswith(".a") ||
      StringRef(InputFile).endswith(".lib"))
    continue;
  auto &JD = *std::prev(IdxToJD.lower_bound(InputFileArgIdx))->second;
  LLVM_DEBUG(dbgs() << "  " << InputFileArgIdx << ": \"" << InputFiledo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  " << InputFileArgIdx
 << ": \"" << InputFile << "\" to " <<
 JD.getName() << "\n";; } } while (false)
                    << "\" to " << JD.getName() << "\n";)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "  " << InputFileArgIdx
 << ": \"" << InputFile << "\" to " <<
 JD.getName() << "\n";; } } while (false);
  auto ObjBuffer = getFile(InputFile);
  if (!ObjBuffer)
    return ObjBuffer.takeError();

  if (S.HarnessFiles.empty()) {
    if (auto Err = S.ObjLayer.add(JD, std::move(*ObjBuffer)))
      return Err;
  } else {
    // We're in -harness mode. Use a custom interface for this
    // test object.
    auto ObjInterface =
        getTestObjectFileInterface(S, (*ObjBuffer)->getMemBufferRef());
    if (!ObjInterface)
      return ObjInterface.takeError();
    if (auto Err = S.ObjLayer.add(JD, std::move(*ObjBuffer),
                                  std::move(*ObjInterface)))
      return Err;
  }
}

return Error::success();
1483}

1485static Expected<MaterializationUnit::Interface>
1486getObjectFileInterfaceHidden(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
auto I = getObjectFileInterface(ES, ObjBuffer);
if (I) {
  for (auto &KV : I->SymbolFlags)
    KV.second &= ~JITSymbolFlags::Exported;
}
return I;
1493}

1495static SmallVector<StringRef, 5> getSearchPathsFromEnvVar(Session &S) {
// FIXME: Handle EPC environment.
SmallVector<StringRef, 5> PathVec;
auto TT = S.ES.getExecutorProcessControl().getTargetTriple();
if (TT.isOSBinFormatCOFF())
  StringRef(getenv("PATH")).split(PathVec, ";");
else if (TT.isOSBinFormatELF())
  StringRef(getenv("LD_LIBRARY_PATH")).split(PathVec, ":");

return PathVec;
1505}

1507static Error addLibraries(Session &S,
                        const std::map<unsigned, JITDylib *> &IdxToJD) {

// 1. Collect search paths for each JITDylib.
DenseMap<const JITDylib *, SmallVector<StringRef, 2>> JDSearchPaths;

for (auto LSPItr = LibrarySearchPaths.begin(),
          LSPEnd = LibrarySearchPaths.end();
     LSPItr != LSPEnd; ++LSPItr) {
  unsigned LibrarySearchPathIdx =
      LibrarySearchPaths.getPosition(LSPItr - LibrarySearchPaths.begin());
  auto &JD = *std::prev(IdxToJD.lower_bound(LibrarySearchPathIdx))->second;

  StringRef LibrarySearchPath = *LSPItr;
  if (sys::fs::get_file_type(LibrarySearchPath) !=
      sys::fs::file_type::directory_file)
    return make_error<StringError>("While linking " + JD.getName() + ", -L" +
                                       LibrarySearchPath +
                                       " does not point to a directory",
                                   inconvertibleErrorCode());

  JDSearchPaths[&JD].push_back(*LSPItr);
}

LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
  if (!JDSearchPaths.empty())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
    dbgs() << "Search paths:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
  for (auto &KV : JDSearchPaths) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
    dbgs() << "  " << KV.first->getName() << ": [";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
    for (auto &LibSearchPath : KV.second)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
      dbgs() << " \"" << LibSearchPath << "\"";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
    dbgs() << " ]\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
  }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { if (!JDSearchPaths.empty()) dbgs() <<
 "Search paths:\n"; for (auto &KV : JDSearchPaths) { dbgs
() << "  " << KV.first->getName() << ": ["
; for (auto &LibSearchPath : KV.second) dbgs() << " \""
 << LibSearchPath << "\""; dbgs() << " ]\n"
; } }; } } while (false);

// 2. Collect library loads
struct LibraryLoad {
  std::string LibName;
  bool IsPath = false;
  unsigned Position;
  StringRef *CandidateExtensions;
  enum { Standard, Hidden } Modifier;
};

// Queue to load library as in the order as it appears in the argument list.
std::deque<LibraryLoad> LibraryLoadQueue;
// Add archive files from the inputs to LibraryLoads.
for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
     InputFileItr != InputFileEnd; ++InputFileItr) {
  StringRef InputFile = *InputFileItr;
  if (!InputFile.endswith(".a") && !InputFile.endswith(".lib"))
    continue;
  LibraryLoad LL;
  LL.LibName = InputFile.str();
  LL.IsPath = true;
  LL.Position = InputFiles.getPosition(InputFileItr - InputFiles.begin());
  LL.CandidateExtensions = nullptr;
  LL.Modifier = LibraryLoad::Standard;
  LibraryLoadQueue.push_back(std::move(LL));
}

// Add -load_hidden arguments to LibraryLoads.
for (auto LibItr = LoadHidden.begin(), LibEnd = LoadHidden.end();
     LibItr != LibEnd; ++LibItr) {
  LibraryLoad LL;
  LL.LibName = *LibItr;
  LL.IsPath = true;
  LL.Position = LoadHidden.getPosition(LibItr - LoadHidden.begin());
  LL.CandidateExtensions = nullptr;
  LL.Modifier = LibraryLoad::Hidden;
  LibraryLoadQueue.push_back(std::move(LL));
}
StringRef StandardExtensions[] = {".so", ".dylib", ".dll", ".a", ".lib"};
StringRef DynLibExtensionsOnly[] = {".so", ".dylib", ".dll"};
StringRef ArchiveExtensionsOnly[] = {".a", ".lib"};

// Add -lx arguments to LibraryLoads.
for (auto LibItr = Libraries.begin(), LibEnd = Libraries.end();
     LibItr != LibEnd; ++LibItr) {
  LibraryLoad LL;
  LL.LibName = *LibItr;
  LL.Position = Libraries.getPosition(LibItr - Libraries.begin());
  LL.CandidateExtensions = StandardExtensions;
  LL.Modifier = LibraryLoad::Standard;
  LibraryLoadQueue.push_back(std::move(LL));
}

// Add -hidden-lx arguments to LibraryLoads.
for (auto LibHiddenItr = LibrariesHidden.begin(),
          LibHiddenEnd = LibrariesHidden.end();
     LibHiddenItr != LibHiddenEnd; ++LibHiddenItr) {
  LibraryLoad LL;
  LL.LibName = *LibHiddenItr;
  LL.Position =
      LibrariesHidden.getPosition(LibHiddenItr - LibrariesHidden.begin());
  LL.CandidateExtensions = ArchiveExtensionsOnly;
  LL.Modifier = LibraryLoad::Hidden;
  LibraryLoadQueue.push_back(std::move(LL));
}

// If there are any load-<modified> options then turn on flag overrides
// to avoid flag mismatch errors.
if (!LibrariesHidden.empty() || !LoadHidden.empty())
  S.ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);

// Sort library loads by position in the argument list.
llvm::sort(LibraryLoadQueue,
           [](const LibraryLoad &LHS, const LibraryLoad &RHS) {
             return LHS.Position < RHS.Position;
           });

// 3. Process library loads.
auto AddArchive = [&](const char *Path, const LibraryLoad &LL)
    -> Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> {
  unique_function<Expected<MaterializationUnit::Interface>(
      ExecutionSession & ES, MemoryBufferRef ObjBuffer)>
      GetObjFileInterface;
  switch (LL.Modifier) {
  case LibraryLoad::Standard:
    GetObjFileInterface = getObjectFileInterface;
    break;
  case LibraryLoad::Hidden:
    GetObjFileInterface = getObjectFileInterfaceHidden;
    break;
  }
  auto G = StaticLibraryDefinitionGenerator::Load(
      S.ObjLayer, Path, S.ES.getExecutorProcessControl().getTargetTriple(),
      std::move(GetObjFileInterface));
  if (!G)
    return G.takeError();

  // Push additional dynamic libraries to search.
  // Note that this mechanism only happens in COFF.
  for (auto FileName : (*G)->getImportedDynamicLibraries()) {
    LibraryLoad NewLL;
    auto FileNameRef = StringRef(FileName);
    if (!FileNameRef.endswith_insensitive(".dll"))
      return make_error<StringError>(
          "COFF Imported library not ending with dll extension?",
          inconvertibleErrorCode());
    NewLL.LibName = FileNameRef.drop_back(strlen(".dll")).str();
    NewLL.Position = LL.Position;
    NewLL.CandidateExtensions = DynLibExtensionsOnly;
    NewLL.Modifier = LibraryLoad::Standard;
    LibraryLoadQueue.push_front(std::move(NewLL));
  }
  return G;
};

SmallVector<StringRef, 5> SystemSearchPaths;
if (SearchSystemLibrary.getValue())
  SystemSearchPaths = getSearchPathsFromEnvVar(S);
while (!LibraryLoadQueue.empty()) {
  bool LibFound = false;
  auto LL = LibraryLoadQueue.front();
  LibraryLoadQueue.pop_front();
  auto &JD = *std::prev(IdxToJD.lower_bound(LL.Position))->second;

  // If this is the name of a JITDylib then link against that.
  if (auto *LJD = S.ES.getJITDylibByName(LL.LibName)) {
    JD.addToLinkOrder(*LJD);
    continue;
  }

  if (LL.IsPath) {
    auto G = AddArchive(LL.LibName.c_str(), LL);
    if (!G)
      return createFileError(LL.LibName, G.takeError());
    JD.addGenerator(std::move(*G));
    LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LL.LibName << " to " << JD.getName() <<
 "\n"; }; } } while (false)
      dbgs() << "Adding generator for static library " << LL.LibName << " to "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LL.LibName << " to " << JD.getName() <<
 "\n"; }; } } while (false)
             << JD.getName() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LL.LibName << " to " << JD.getName() <<
 "\n"; }; } } while (false)
    })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LL.LibName << " to " << JD.getName() <<
 "\n"; }; } } while (false);
    continue;
  }

  // Otherwise look through the search paths.
  auto CurJDSearchPaths = JDSearchPaths[&JD];
  for (StringRef SearchPath :
       concat<StringRef>(CurJDSearchPaths, SystemSearchPaths)) {
    for (const char *LibExt : {".dylib", ".so", ".dll", ".a", ".lib"}) {
      SmallVector<char, 256> LibPath;
      LibPath.reserve(SearchPath.size() + strlen("lib") + LL.LibName.size() +
                      strlen(LibExt) + 2); // +2 for pathsep, null term.
      llvm::copy(SearchPath, std::back_inserter(LibPath));
      if (StringRef(LibExt) != ".lib" && StringRef(LibExt) != ".dll")
        sys::path::append(LibPath, "lib" + LL.LibName + LibExt);
      else
        sys::path::append(LibPath, LL.LibName + LibExt);
      LibPath.push_back('\0');

      // Skip missing or non-regular paths.
      if (sys::fs::get_file_type(LibPath.data()) !=
          sys::fs::file_type::regular_file) {
        continue;
      }

      file_magic Magic;
      if (auto EC = identify_magic(LibPath, Magic)) {
        // If there was an error loading the file then skip it.
        LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but could not identify file type ("
 << EC.message() << "). Skipping.\n"; }; } } while
 (false)
          dbgs() << "Library search found \"" << LibPathdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but could not identify file type ("
 << EC.message() << "). Skipping.\n"; }; } } while
 (false)
                 << "\", but could not identify file type (" << EC.message()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but could not identify file type ("
 << EC.message() << "). Skipping.\n"; }; } } while
 (false)
                 << "). Skipping.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but could not identify file type ("
 << EC.message() << "). Skipping.\n"; }; } } while
 (false)
        })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but could not identify file type ("
 << EC.message() << "). Skipping.\n"; }; } } while
 (false);
        continue;
      }

      // We identified the magic. Assume that we can load it -- we'll reset
      // in the default case.
      LibFound = true;
      switch (Magic) {
      case file_magic::pecoff_executable:
      case file_magic::elf_shared_object:
      case file_magic::macho_dynamically_linked_shared_lib: {
        if (auto Err = S.loadAndLinkDynamicLibrary(JD, LibPath.data()))
          return Err;
        break;
      }
      case file_magic::archive:
      case file_magic::macho_universal_binary: {
        auto G = AddArchive(LibPath.data(), LL);
        if (!G)
          return G.takeError();
        JD.addGenerator(std::move(*G));
        LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LibPath.data() << " to " << JD.getName(
) << "\n"; }; } } while (false)
          dbgs() << "Adding generator for static library " << LibPath.data()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LibPath.data() << " to " << JD.getName(
) << "\n"; }; } } while (false)
                 << " to " << JD.getName() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LibPath.data() << " to " << JD.getName(
) << "\n"; }; } } while (false)
        })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Adding generator for static library "
 << LibPath.data() << " to " << JD.getName(
) << "\n"; }; } } while (false);
        break;
      }
      default:
        // This file isn't a recognized library kind.
        LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but file type is not supported. Skipping.\n"
; }; } } while (false)
          dbgs() << "Library search found \"" << LibPathdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but file type is not supported. Skipping.\n"
; }; } } while (false)
                 << "\", but file type is not supported. Skipping.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but file type is not supported. Skipping.\n"
; }; } } while (false)
        })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Library search found \""
 << LibPath << "\", but file type is not supported. Skipping.\n"
; }; } } while (false);
        LibFound = false;
        break;
      }
      if (LibFound)
        break;
    }
    if (LibFound)
      break;
  }

  if (!LibFound)
    return make_error<StringError>("While linking " + JD.getName() +
                                       ", could not find library for -l" +
                                       LL.LibName,
                                   inconvertibleErrorCode());
}

return Error::success();
1762}

1764static Error addSessionInputs(Session &S) {
std::map<unsigned, JITDylib *> IdxToJD;

if (auto Err = createJITDylibs(S, IdxToJD))
  return Err;

if (auto Err = addAbsoluteSymbols(S, IdxToJD))
  return Err;

if (auto Err = addAliases(S, IdxToJD))
  return Err;

if (!TestHarnesses.empty())
  if (auto Err = addTestHarnesses(S))
    return Err;

if (auto Err = addObjects(S, IdxToJD))
  return Err;

if (auto Err = addLibraries(S, IdxToJD))
  return Err;

return Error::success();
1787}

1789namespace {
1790struct TargetInfo {
const Target *TheTarget;
std::unique_ptr<MCSubtargetInfo> STI;
std::unique_ptr<MCRegisterInfo> MRI;
std::unique_ptr<MCAsmInfo> MAI;
std::unique_ptr<MCContext> Ctx;
std::unique_ptr<MCDisassembler> Disassembler;
std::unique_ptr<MCInstrInfo> MII;
std::unique_ptr<MCInstrAnalysis> MIA;
std::unique_ptr<MCInstPrinter> InstPrinter;
1800};
1801} // anonymous namespace

1803static TargetInfo getTargetInfo(const Triple &TT) {
auto TripleName = TT.str();
std::string ErrorStr;
const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, ErrorStr);
if (!TheTarget)
  ExitOnErr(make_error<StringError>("Error accessing target '" + TripleName +
                                        "': " + ErrorStr,
                                    inconvertibleErrorCode()));

std::unique_ptr<MCSubtargetInfo> STI(
    TheTarget->createMCSubtargetInfo(TripleName, "", ""));
if (!STI)
  ExitOnErr(
      make_error<StringError>("Unable to create subtarget for " + TripleName,
                              inconvertibleErrorCode()));

std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
if (!MRI)
  ExitOnErr(make_error<StringError>("Unable to create target register info "
                                    "for " +
                                        TripleName,
                                    inconvertibleErrorCode()));

MCTargetOptions MCOptions;
std::unique_ptr<MCAsmInfo> MAI(
    TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
if (!MAI)
  ExitOnErr(make_error<StringError>("Unable to create target asm info " +
                                        TripleName,
                                    inconvertibleErrorCode()));

auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(),
                                       MRI.get(), STI.get());

std::unique_ptr<MCDisassembler> Disassembler(
    TheTarget->createMCDisassembler(*STI, *Ctx));
if (!Disassembler)
  ExitOnErr(make_error<StringError>("Unable to create disassembler for " +
                                        TripleName,
                                    inconvertibleErrorCode()));

std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
if (!MII)
  ExitOnErr(make_error<StringError>("Unable to create instruction info for" +
                                        TripleName,
                                    inconvertibleErrorCode()));

std::unique_ptr<MCInstrAnalysis> MIA(
    TheTarget->createMCInstrAnalysis(MII.get()));
if (!MIA)
  ExitOnErr(make_error<StringError>(
      "Unable to create instruction analysis for" + TripleName,
      inconvertibleErrorCode()));

std::unique_ptr<MCInstPrinter> InstPrinter(
    TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI));
if (!InstPrinter)
  ExitOnErr(make_error<StringError>(
      "Unable to create instruction printer for" + TripleName,
      inconvertibleErrorCode()));
return {TheTarget,      std::move(STI), std::move(MRI),
        std::move(MAI), std::move(Ctx), std::move(Disassembler),
        std::move(MII), std::move(MIA), std::move(InstPrinter)};
1866}

1868static Error runChecks(Session &S) {
const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();

if (CheckFiles.empty())
  return Error::success();

LLVM_DEBUG(dbgs() << "Running checks...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Running checks...\n"; } }
 while (false);

auto TI = getTargetInfo(TT);

auto IsSymbolValid = [&S](StringRef Symbol) {
  return S.isSymbolRegistered(Symbol);
};

auto GetSymbolInfo = [&S](StringRef Symbol) {
  return S.findSymbolInfo(Symbol, "Can not get symbol info");
};

auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) {
  return S.findSectionInfo(FileName, SectionName);
};

auto GetStubInfo = [&S](StringRef FileName, StringRef SectionName) {
  return S.findStubInfo(FileName, SectionName);
};

auto GetGOTInfo = [&S](StringRef FileName, StringRef SectionName) {
  return S.findGOTEntryInfo(FileName, SectionName);
};

RuntimeDyldChecker Checker(
    IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo,
    TT.isLittleEndian() ? support::little : support::big,
    TI.Disassembler.get(), TI.InstPrinter.get(), dbgs());

std::string CheckLineStart = "# " + CheckName + ":";
for (auto &CheckFile : CheckFiles) {
  auto CheckerFileBuf = ExitOnErr(getFile(CheckFile));
  if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf))
    ExitOnErr(make_error<StringError>(
        "Some checks in " + CheckFile + " failed", inconvertibleErrorCode()));
}

return Error::success();
1912}

1914static Error addSelfRelocations(LinkGraph &G) {
auto TI = getTargetInfo(G.getTargetTriple());
for (auto *Sym : G.defined_symbols())
  if (Sym->isCallable())
    if (auto Err = addFunctionPointerRelocationsToCurrentSymbol(
            *Sym, G, *TI.Disassembler, *TI.MIA))
      return Err;
return Error::success();
1922}

1924static void dumpSessionStats(Session &S) {
if (!ShowSizes)
  return;
if (!OrcRuntime.empty())
  outs() << "Note: Session stats include runtime and entry point lookup, but "
            "not JITDylib initialization/deinitialization.\n";
if (ShowSizes)
  outs() << "  Total size of all blocks before pruning: "
         << S.SizeBeforePruning
         << "\n  Total size of all blocks after fixups: " << S.SizeAfterFixups
         << "\n";
1935}

1937static Expected<JITEvaluatedSymbol> getMainEntryPoint(Session &S) {
return S.ES.lookup(S.JDSearchOrder, S.ES.intern(EntryPointName));
1939}

1941static Expected<JITEvaluatedSymbol> getOrcRuntimeEntryPoint(Session &S) {
std::string RuntimeEntryPoint = "__orc_rt_run_program_wrapper";
const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();
if (TT.getObjectFormat() == Triple::MachO)
  RuntimeEntryPoint = '_' + RuntimeEntryPoint;
return S.ES.lookup(S.JDSearchOrder, S.ES.intern(RuntimeEntryPoint));
1947}

1949static Expected<JITEvaluatedSymbol> getEntryPoint(Session &S) {
JITEvaluatedSymbol EntryPoint;

// Find the entry-point function unconditionally, since we want to force
// it to be materialized to collect stats.
if (auto EP = getMainEntryPoint(S))
  EntryPoint = *EP;
else
  return EP.takeError();
LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Using entry point \"" <<
 EntryPointName << "\": " << formatv("{0:x16}", EntryPoint
.getAddress()) << "\n"; }; } } while (false)
  dbgs() << "Using entry point \"" << EntryPointNamedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Using entry point \"" <<
 EntryPointName << "\": " << formatv("{0:x16}", EntryPoint
.getAddress()) << "\n"; }; } } while (false)
         << "\": " << formatv("{0:x16}", EntryPoint.getAddress()) << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Using entry point \"" <<
 EntryPointName << "\": " << formatv("{0:x16}", EntryPoint
.getAddress()) << "\n"; }; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "Using entry point \"" <<
 EntryPointName << "\": " << formatv("{0:x16}", EntryPoint
.getAddress()) << "\n"; }; } } while (false);

// If we're running with the ORC runtime then replace the entry-point
// with the __orc_rt_run_program symbol.
if (!OrcRuntime.empty()) {
  if (auto EP = getOrcRuntimeEntryPoint(S))
    EntryPoint = *EP;
  else
    return EP.takeError();
  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "(called via __orc_rt_run_program_wrapper at "
 << formatv("{0:x16}", EntryPoint.getAddress()) <<
 ")\n"; }; } } while (false)
    dbgs() << "(called via __orc_rt_run_program_wrapper at "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "(called via __orc_rt_run_program_wrapper at "
 << formatv("{0:x16}", EntryPoint.getAddress()) <<
 ")\n"; }; } } while (false)
           << formatv("{0:x16}", EntryPoint.getAddress()) << ")\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "(called via __orc_rt_run_program_wrapper at "
 << formatv("{0:x16}", EntryPoint.getAddress()) <<
 ")\n"; }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { { dbgs() << "(called via __orc_rt_run_program_wrapper at "
 << formatv("{0:x16}", EntryPoint.getAddress()) <<
 ")\n"; }; } } while (false);
}

return EntryPoint;
1977}

1979static Expected<int> runWithRuntime(Session &S, ExecutorAddr EntryPointAddr) {
StringRef DemangledEntryPoint = EntryPointName;
const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();
if (TT.getObjectFormat() == Triple::MachO &&
22
←
Assuming the condition is false→
    DemangledEntryPoint.front() == '_')
  DemangledEntryPoint = DemangledEntryPoint.drop_front();
using llvm::orc::shared::SPSString;
using SPSRunProgramSig =
    int64_t(SPSString, SPSString, shared::SPSSequence<SPSString>);
int64_t Result;
if (auto Err = S.ES.callSPSWrapper<SPSRunProgramSig>(
23
←
Assuming the condition is false→
24
←
Taking false branch→
        EntryPointAddr, Result, S.MainJD->getName(), DemangledEntryPoint,
        static_cast<std::vector<std::string> &>(InputArgv)))
  return std::move(Err);
return Result;
25
←
Calling constructor for 'Expected<int>'→
1994}

1996static Expected<int> runWithoutRuntime(Session &S,
                                     ExecutorAddr EntryPointAddr) {
return S.ES.getExecutorProcessControl().runAsMain(EntryPointAddr, InputArgv);
1999}

2001namespace {
2002struct JITLinkTimers {
TimerGroup JITLinkTG{"llvm-jitlink timers", "timers for llvm-jitlink phases"};
Timer LoadObjectsTimer{"load", "time to load/add object files", JITLinkTG};
Timer LinkTimer{"link", "time to link object files", JITLinkTG};
Timer RunTimer{"run", "time to execute jitlink'd code", JITLinkTG};
2007};
2008} // namespace

2010int main(int argc, char *argv[]) {
InitLLVM X(argc, argv);

InitializeAllTargetInfos();
InitializeAllTargetMCs();
InitializeAllDisassemblers();

cl::HideUnrelatedOptions({&JITLinkCategory, &getColorCategory()});
cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool");
ExitOnErr.setBanner(std::string(argv[0]) + ": ");

/// If timers are enabled, create a JITLinkTimers instance.
std::unique_ptr<JITLinkTimers> Timers =
    ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
1
Assuming the condition is false→
2
←
'?' condition is false→

ExitOnErr(sanitizeArguments(getFirstFileTriple(), argv[0]));

auto S = ExitOnErr(Session::Create(getFirstFileTriple()));

{
  TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr);
3
←
'?' condition is false→
  ExitOnErr(addSessionInputs(*S));
}

if (PhonyExternals)
4
←
Assuming the condition is false→
5
←
Taking false branch→
  addPhonyExternalsGenerator(*S);

if (ShowInitialExecutionSessionState)
6
←
Assuming the condition is false→
7
←
Taking false branch→
  S->ES.dump(outs());

Expected<JITEvaluatedSymbol> EntryPoint(nullptr);
{
  ExpectedAsOutParameter<JITEvaluatedSymbol> _(&EntryPoint);
  TimeRegion TR(Timers ? &Timers->LinkTimer : nullptr);
8
←
'?' condition is false→
  EntryPoint = getEntryPoint(*S);
}

// Print any reports regardless of whether we succeeded or failed.
if (ShowEntryExecutionSessionState)
9
←
Assuming the condition is false→
10
←
Taking false branch→
  S->ES.dump(outs());

if (ShowAddrs)
11
←
Assuming the condition is false→
12
←
Taking false branch→
  S->dumpSessionInfo(outs());

dumpSessionStats(*S);

if (!EntryPoint) {
13
←
Taking false branch→
  if (Timers)
    Timers->JITLinkTG.printAll(errs());
  reportLLVMJITLinkError(EntryPoint.takeError());
  exit(1);
}

ExitOnErr(runChecks(*S));

if (NoExec)
14
←
Assuming the condition is false→
15
←
Taking false branch→
  return 0;

int Result = 0;
{
  LLVM_DEBUG(dbgs() << "Running \"" << EntryPointName << "\"...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("llvm_jitlink")) { dbgs() << "Running \"" << EntryPointName
 << "\"...\n"; } } while (false);
16
←
Assuming 'DebugFlag' is false→
  TimeRegion TR(Timers ? &Timers->RunTimer : nullptr);
17
←
Loop condition is false.  Exiting loop→
18
←
'?' condition is false→
  if (!OrcRuntime.empty())
19
←
Assuming the condition is true→
20
←
Taking true branch→
    Result =
        ExitOnErr(runWithRuntime(*S, ExecutorAddr(EntryPoint->getAddress())));
21
←
Calling 'runWithRuntime'→
  else
    Result = ExitOnErr(
        runWithoutRuntime(*S, ExecutorAddr(EntryPoint->getAddress())));
}

// Destroy the session.
ExitOnErr(S->ES.endSession());
S.reset();

if (Timers)
  Timers->JITLinkTG.printAll(errs());

// If the executing code set a test result override then use that.
if (UseTestResultOverride)
  Result = TestResultOverride;

return Result;
2092}

←

/build/source/llvm/include/llvm/Support/Error.h

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