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

Bug Summary

File:	build/source/llvm/include/llvm/Support/Error.h
Warning:	line 520, 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-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -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-17/lib/clang/17/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 1683717183 -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-2023-05-10-133810-16478-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: <alias-name>=<aliasee>)"),
          cl::cat(JITLinkCategory));

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

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

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

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

178static cl::opt<std::string> ShowLinkGraphs(
  "show-graphs",
  cl::desc("Takes a posix regex and prints the link graphs of all files "
           "matching that regex after fixups have been applied"),
  cl::Optional, cl::cat(JITLinkCategory));

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

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

193static 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));

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

205static 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));

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

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

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

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

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

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

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

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

248static ExitOnError ExitOnErr;

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

257static bool UseTestResultOverride = false;
258static int64_t TestResultOverride = 0;

260extern "C" LLVM_ATTRIBUTE_USED__attribute__((__used__)) void
261llvm_jitlink_setTestResultOverride(int64_t Value) {
TestResultOverride = Value;
UseTestResultOverride = true;
264}

266static Error addSelfRelocations(LinkGraph &G);

268namespace {

270template <typename ErrT>

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

283private:
bool C;
285};

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

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

301} // end anonymous namespace

303namespace llvm {

305static raw_ostream &
306operator<<(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)";
312}

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

322static raw_ostream &
323operator<<(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;
331}

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

340static 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();
389}

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

398static 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";
}
464}

466// A memory mapper with a fake offset applied only used for -noexec testing
467class InProcessDeltaMapper final : public InProcessMemoryMapper {
468public:
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", 496, __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, make all segments read-writable, and
  // discard allocation actions.
  auto FixedAI = std::move(AI);
  FixedAI.MappingBase -= DeltaAddr;
  for (auto &Seg : FixedAI.Segments)
    Seg.AG = {MemProt::Read | MemProt::Write, Seg.AG.getMemLifetimePolicy()};
  FixedAI.Actions.clear();
  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));
}

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

552Expected<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;
573}

575static std::unique_ptr<JITLinkMemoryManager> createInProcessMemoryManager() {
uint64_t SlabSize;
577#ifdef _WIN32
SlabSize = 1024 * 1024;
579#else
SlabSize = 1024 * 1024 * 1024;
581#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));
597}

599Expected<std::unique_ptr<jitlink::JITLinkMemoryManager>>
600createSharedMemoryManager(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);

614#ifdef _WIN32
size_t SlabSize = 1024 * 1024;
616#else
size_t SlabSize = 1024 * 1024 * 1024;
618#endif

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

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


628static Expected<MaterializationUnit::Interface>
629getTestObjectFileInterface(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;
693}

695static 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();
705}

707static 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();
716}

718static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() {
719#ifndef LLVM_ON_UNIX1
// FIXME: Add support for Windows.
return make_error<StringError>("-" + OutOfProcessExecutor.ArgStr +
                                   " not supported on non-unix platforms",
                               inconvertibleErrorCode());
724#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());
731#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]);
791#endif
792}

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

802static 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;
837}
838#endif

840static Expected<std::unique_ptr<ExecutorProcessControl>> connectToExecutor() {
841#ifndef LLVM_ON_UNIX1
// FIXME: Add TCP support for Windows.
return make_error<StringError>("-" + OutOfProcessExecutorConnect.ArgStr +
                                   " not supported on non-unix platforms",
                               inconvertibleErrorCode());
846#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());
853#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);
881#endif
882}

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

896Expected<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);
927}

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

934Session::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(JITDylib &JD, ResourceKey K) override {
    return Error::success();
  }
  void notifyTransferringResources(JITDylib &JD, 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"),
        {ExecutorAddr::fromPtr(llvm_jitlink_setTestResultOverride),
         JITSymbolFlags::Exported}}})));
  MainJD->addToLinkOrder(TestResultJD);
}

ExitOnErr(loadDylibs(*this));

auto &TT = ES.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)), true, true));
}

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

if (!ShowLinkGraphs.empty())
  ShowGraphsRegex = Regex(ShowLinkGraphs);
1069}

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

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

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

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

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

if (ShowGraphsRegex)
  PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error {
    // Print graph if ShowLinkGraphs is specified-but-empty, or if
    // it contains the given graph.
    if (ShowGraphsRegex->match(G.getName())) {
      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);
1127}

1129Expected<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;
1146}

1148Error 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();
1158}

1160Expected<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;
1166}

1168Expected<Session::MemoryRegionInfo &>
1169Session::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;
1180}

1182Expected<Session::MemoryRegionInfo &>
1183Session::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;
1194}

1196Expected<Session::MemoryRegionInfo &>
1197Session::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;
1208}

1210bool Session::isSymbolRegistered(StringRef SymbolName) {
return SymbolInfos.count(SymbolName);
1212}

1214Expected<Session::MemoryRegionInfo &>
1215Session::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;
1222}

1224} // end namespace llvm

1226static 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", 1228, __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;
1254}

1256static 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();
1340}

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

1346static 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();
1377}

1379static 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());
  ExecutorSymbolDef AbsDef(ExecutorAddr(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();
1413}

1415static 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();
1440}

1442static 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();
1453}

1455static 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();
1492}

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

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

return PathVec;
1514}

1516static 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, 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();
1770}

1772static 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();
1795}

1797namespace {
1798struct 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;
1808};
1809} // anonymous namespace

1811static 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)};
1874}

1876static Error runChecks(Session &S) {
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(S.ES.getTargetTriple());

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,
    S.ES.getTargetTriple().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();
1918}

1920static 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();
1928}

1930static 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";
1941}

1943static Expected<ExecutorSymbolDef> getMainEntryPoint(Session &S) {
return S.ES.lookup(S.JDSearchOrder, S.ES.intern(EntryPointName));
1945}

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

1954static Expected<ExecutorSymbolDef> getEntryPoint(Session &S) {
ExecutorSymbolDef 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;
1982}

1984static Expected<int> runWithRuntime(Session &S, ExecutorAddr EntryPointAddr) {
StringRef DemangledEntryPoint = EntryPointName;
if (S.ES.getTargetTriple().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>'→
1998}

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

2005namespace {
2006struct 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};
2011};
2012} // namespace

2014int 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<ExecutorSymbolDef> EntryPoint((ExecutorSymbolDef()));
{
  ExpectedAsOutParameter<ExecutorSymbolDef> _(&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;
2096}

←

/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 <optional>
35#include <string>
36#include <system_error>
37#include <type_traits>
38#include <utility>
39#include <vector>
40 
41namespace llvm {
42 
43class ErrorSuccess;
44 
45/// Base class for error info classes. Do not extend this directly: Extend
46/// the ErrorInfo template subclass instead.
47class ErrorInfoBase {
48public:
49  virtual ~ErrorInfoBase() = default;
50 
51  /// Print an error message to an output stream.
52  virtual void log(raw_ostream &OS) const = 0;
53 
54  /// Return the error message as a string.
55  virtual std::string message() const {
56    std::string Msg;
57    raw_string_ostream OS(Msg);
58    log(OS);
59    return OS.str();
60  }
61 
62  /// Convert this error to a std::error_code.
63  ///
64  /// This is a temporary crutch to enable interaction with code still
65  /// using std::error_code. It will be removed in the future.
66  virtual std::error_code convertToErrorCode() const = 0;
67 
68  // Returns the class ID for this type.
69  static const void *classID() { return &ID; }
70 
71  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
72  virtual const void *dynamicClassID() const = 0;
73 
74  // Check whether this instance is a subclass of the class identified by
75  // ClassID.
76  virtual bool isA(const void *const ClassID) const {
77    return ClassID == classID();
78  }
79 
80  // Check whether this instance is a subclass of ErrorInfoT.
81  template <typename ErrorInfoT> bool isA() const {
82    return isA(ErrorInfoT::classID());
83  }
84 
85private:
86  virtual void anchor();
87 
88  static char ID;
89};
90 
91/// Lightweight error class with error context and mandatory checking.
92///
93/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
94/// are represented by setting the pointer to a ErrorInfoBase subclass
95/// instance containing information describing the failure. Success is
96/// represented by a null pointer value.
97///
98/// Instances of Error also contains a 'Checked' flag, which must be set
99/// before the destructor is called, otherwise the destructor will trigger a
100/// runtime error. This enforces at runtime the requirement that all Error
101/// instances be checked or returned to the caller.
102///
103/// There are two ways to set the checked flag, depending on what state the
104/// Error instance is in. For Error instances indicating success, it
105/// is sufficient to invoke the boolean conversion operator. E.g.:
106///
107///   @code{.cpp}
108///   Error foo(<...>);
109///
110///   if (auto E = foo(<...>))
111///     return E; // <- Return E if it is in the error state.
112///   // We have verified that E was in the success state. It can now be safely
113///   // destroyed.
114///   @endcode
115///
116/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
117/// without testing the return value will raise a runtime error, even if foo
118/// returns success.
119///
120/// For Error instances representing failure, you must use either the
121/// handleErrors or handleAllErrors function with a typed handler. E.g.:
122///
123///   @code{.cpp}
124///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
125///     // Custom error info.
126///   };
127///
128///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
129///
130///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
131///   auto NewE =
132///     handleErrors(E,
133///       [](const MyErrorInfo &M) {
134///         // Deal with the error.
135///       },
136///       [](std::unique_ptr<OtherError> M) -> Error {
137///         if (canHandle(*M)) {
138///           // handle error.
139///           return Error::success();
140///         }
141///         // Couldn't handle this error instance. Pass it up the stack.
142///         return Error(std::move(M));
143///       );
144///   // Note - we must check or return NewE in case any of the handlers
145///   // returned a new error.
146///   @endcode
147///
148/// The handleAllErrors function is identical to handleErrors, except
149/// that it has a void return type, and requires all errors to be handled and
150/// no new errors be returned. It prevents errors (assuming they can all be
151/// handled) from having to be bubbled all the way to the top-level.
152///
153/// *All* Error instances must be checked before destruction, even if
154/// they're moved-assigned or constructed from Success values that have already
155/// been checked. This enforces checking through all levels of the call stack.
156class [[nodiscard]] Error {
157  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
158  // to add to the error list. It can't rely on handleErrors for this, since
159  // handleErrors does not support ErrorList handlers.
160  friend class ErrorList;
161 
162  // handleErrors needs to be able to set the Checked flag.
163  template <typename... HandlerTs>
164  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
165 
166  // Expected<T> needs to be able to steal the payload when constructed from an
167  // error.
168  template <typename T> friend class Expected;
169 
170  // wrap needs to be able to steal the payload.
171  friend LLVMErrorRef wrap(Error);
172 
173protected:
174  /// Create a success value. Prefer using 'Error::success()' for readability
175  Error() {
176    setPtr(nullptr);
177    setChecked(false);
178  }
179 
180public:
181  /// Create a success value.
182  static ErrorSuccess success();
183 
184  // Errors are not copy-constructable.
185  Error(const Error &Other) = delete;
186 
187  /// Move-construct an error value. The newly constructed error is considered
188  /// unchecked, even if the source error had been checked. The original error
189  /// becomes a checked Success value, regardless of its original state.
190  Error(Error &&Other) {
191    setChecked(true);
192    *this = std::move(Other);
193  }
194 
195  /// Create an error value. Prefer using the 'make_error' function, but
196  /// this constructor can be useful when "re-throwing" errors from handlers.
197  Error(std::unique_ptr<ErrorInfoBase> Payload) {
198    setPtr(Payload.release());
199    setChecked(false);
200  }
201 
202  // Errors are not copy-assignable.
203  Error &operator=(const Error &Other) = delete;
204 
205  /// Move-assign an error value. The current error must represent success, you
206  /// you cannot overwrite an unhandled error. The current error is then
207  /// considered unchecked. The source error becomes a checked success value,
208  /// regardless of its original state.
209  Error &operator=(Error &&Other) {
210    // Don't allow overwriting of unchecked values.
211    assertIsChecked();
212    setPtr(Other.getPtr());
213 
214    // This Error is unchecked, even if the source error was checked.
215    setChecked(false);
216 
217    // Null out Other's payload and set its checked bit.
218    Other.setPtr(nullptr);
219    Other.setChecked(true);
220 
221    return *this;
222  }
223 
224  /// Destroy a Error. Fails with a call to abort() if the error is
225  /// unchecked.
226  ~Error() {
227    assertIsChecked();
228    delete getPtr();
229  }
230 
231  /// Bool conversion. Returns true if this Error is in a failure state,
232  /// and false if it is in an accept state. If the error is in a Success state
233  /// it will be considered checked.
234  explicit operator bool() {
235    setChecked(getPtr() == nullptr);
236    return getPtr() != nullptr;
237  }
238 
239  /// Check whether one error is a subclass of another.
240  template <typename ErrT> bool isA() const {
241    return getPtr() && getPtr()->isA(ErrT::classID());
242  }
243 
244  /// Returns the dynamic class id of this error, or null if this is a success
245  /// value.
246  const void* dynamicClassID() const {
247    if (!getPtr())
248      return nullptr;
249    return getPtr()->dynamicClassID();
250  }
251 
252private:
253#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
254  // assertIsChecked() happens very frequently, but under normal circumstances
255  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
256  // of debug prints can cause the function to be too large for inlining.  So
257  // it's important that we define this function out of line so that it can't be
258  // inlined.
259  [[noreturn]] void fatalUncheckedError() const;
260#endif
261 
262  void assertIsChecked() {
263#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
264    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
265      fatalUncheckedError();
266#endif
267  }
268 
269  ErrorInfoBase *getPtr() const {
270#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
271    return reinterpret_cast<ErrorInfoBase*>(
272             reinterpret_cast<uintptr_t>(Payload) &
273             ~static_cast<uintptr_t>(0x1));
274#else
275    return Payload;
276#endif
277  }
278 
279  void setPtr(ErrorInfoBase *EI) {
280#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
281    Payload = reinterpret_cast<ErrorInfoBase*>(
282                (reinterpret_cast<uintptr_t>(EI) &
283                 ~static_cast<uintptr_t>(0x1)) |
284                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
285#else
286    Payload = EI;
287#endif
288  }
289 
290  bool getChecked() const {
291#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
292    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
293#else
294    return true;
295#endif
296  }
297 
298  void setChecked(bool V) {
299#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
300    Payload = reinterpret_cast<ErrorInfoBase*>(
301                (reinterpret_cast<uintptr_t>(Payload) &
302                  ~static_cast<uintptr_t>(0x1)) |
303                  (V ? 0 : 1));
304#endif
305  }
306 
307  std::unique_ptr<ErrorInfoBase> takePayload() {
308    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
309    setPtr(nullptr);
310    setChecked(true);
311    return Tmp;
312  }
313 
314  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
315    if (auto *P = E.getPtr())
316      P->log(OS);
317    else
318      OS << "success";
319    return OS;
320  }
321 
322  ErrorInfoBase *Payload = nullptr;
323};
324 
325/// Subclass of Error for the sole purpose of identifying the success path in
326/// the type system. This allows to catch invalid conversion to Expected<T> at
327/// compile time.
328class ErrorSuccess final : public Error {};
329 
330inline ErrorSuccess Error::success() { return ErrorSuccess(); }
331 
332/// Make a Error instance representing failure using the given error info
333/// type.
334template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
335  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
336}
337 
338/// Base class for user error types. Users should declare their error types
339/// like:
340///
341/// class MyError : public ErrorInfo<MyError> {
342///   ....
343/// };
344///
345/// This class provides an implementation of the ErrorInfoBase::kind
346/// method, which is used by the Error RTTI system.
347template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
348class ErrorInfo : public ParentErrT {
349public:
350  using ParentErrT::ParentErrT; // inherit constructors
351 
352  static const void *classID() { return &ThisErrT::ID; }
353 
354  const void *dynamicClassID() const override { return &ThisErrT::ID; }
355 
356  bool isA(const void *const ClassID) const override {
357    return ClassID == classID() || ParentErrT::isA(ClassID);
358  }
359};
360 
361/// Special ErrorInfo subclass representing a list of ErrorInfos.
362/// Instances of this class are constructed by joinError.
363class ErrorList final : public ErrorInfo<ErrorList> {
364  // handleErrors needs to be able to iterate the payload list of an
365  // ErrorList.
366  template <typename... HandlerTs>
367  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
368 
369  // joinErrors is implemented in terms of join.
370  friend Error joinErrors(Error, Error);
371 
372public:
373  void log(raw_ostream &OS) const override {
374    OS << "Multiple errors:\n";
375    for (const auto &ErrPayload : Payloads) {
376      ErrPayload->log(OS);
377      OS << "\n";
378    }
379  }
380 
381  std::error_code convertToErrorCode() const override;
382 
383  // Used by ErrorInfo::classID.
384  static char ID;
385 
386private:
387  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
388            std::unique_ptr<ErrorInfoBase> Payload2) {
389    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", 390, __extension__ __PRETTY_FUNCTION__
))
390           "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", 390, __extension__ __PRETTY_FUNCTION__
));
391    Payloads.push_back(std::move(Payload1));
392    Payloads.push_back(std::move(Payload2));
393  }
394 
395  static Error join(Error E1, Error E2) {
396    if (!E1)
397      return E2;
398    if (!E2)
399      return E1;
400    if (E1.isA<ErrorList>()) {
401      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
402      if (E2.isA<ErrorList>()) {
403        auto E2Payload = E2.takePayload();
404        auto &E2List = static_cast<ErrorList &>(*E2Payload);
405        for (auto &Payload : E2List.Payloads)
406          E1List.Payloads.push_back(std::move(Payload));
407      } else
408        E1List.Payloads.push_back(E2.takePayload());
409 
410      return E1;
411    }
412    if (E2.isA<ErrorList>()) {
413      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
414      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
415      return E2;
416    }
417    return Error(std::unique_ptr<ErrorList>(
418        new ErrorList(E1.takePayload(), E2.takePayload())));
419  }
420 
421  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
422};
423 
424/// Concatenate errors. The resulting Error is unchecked, and contains the
425/// ErrorInfo(s), if any, contained in E1, followed by the
426/// ErrorInfo(s), if any, contained in E2.
427inline Error joinErrors(Error E1, Error E2) {
428  return ErrorList::join(std::move(E1), std::move(E2));
429}
430 
431/// Tagged union holding either a T or a Error.
432///
433/// This class parallels ErrorOr, but replaces error_code with Error. Since
434/// Error cannot be copied, this class replaces getError() with
435/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
436/// error class type.
437///
438/// Example usage of 'Expected<T>' as a function return type:
439///
440///   @code{.cpp}
441///     Expected<int> myDivide(int A, int B) {
442///       if (B == 0) {
443///         // return an Error
444///         return createStringError(inconvertibleErrorCode(),
445///                                  "B must not be zero!");
446///       }
447///       // return an integer
448///       return A / B;
449///     }
450///   @endcode
451///
452///   Checking the results of to a function returning 'Expected<T>':
453///   @code{.cpp}
454///     if (auto E = Result.takeError()) {
455///       // We must consume the error. Typically one of:
456///       // - return the error to our caller
457///       // - toString(), when logging
458///       // - consumeError(), to silently swallow the error
459///       // - handleErrors(), to distinguish error types
460///       errs() << "Problem with division " << toString(std::move(E)) << "\n";
461///       return;
462///     }
463///     // use the result
464///     outs() << "The answer is " << *Result << "\n";
465///   @endcode
466///
467///  For unit-testing a function returning an 'Expected<T>', see the
468///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
469 
470template <class T> class [[nodiscard]] Expected {
471  template <class T1> friend class ExpectedAsOutParameter;
472  template <class OtherT> friend class Expected;
473 
474  static constexpr bool isRef = std::is_reference_v<T>;
475 
476  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
477 
478  using error_type = std::unique_ptr<ErrorInfoBase>;
479 
480public:
481  using storage_type = std::conditional_t<isRef, wrap, T>;
482  using value_type = T;
483 
484private:
485  using reference = std::remove_reference_t<T> &;
486  using const_reference = const std::remove_reference_t<T> &;
487  using pointer = std::remove_reference_t<T> *;
488  using const_pointer = const std::remove_reference_t<T> *;
489 
490public:
491  /// Create an Expected<T> error value from the given Error.
492  Expected(Error Err)
493      : HasError(true)
494#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
495        // Expected is unchecked upon construction in Debug builds.
496        , Unchecked(true)
497#endif
498  {
499    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", 499, __extension__ __PRETTY_FUNCTION__
));
500    new (getErrorStorage()) error_type(Err.takePayload());
501  }
502 
503  /// Forbid to convert from Error::success() implicitly, this avoids having
504  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
505  /// but triggers the assertion above.
506  Expected(ErrorSuccess) = delete;
507 
508  /// Create an Expected<T> success value from the given OtherT value, which
509  /// must be convertible to T.
510  template <typename OtherT>
511  Expected(OtherT &&Val,
512           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = nullptr)
513      : HasError(false)
514#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
515        // Expected is unchecked upon construction in Debug builds.
516        ,
517        Unchecked(true)
518#endif
519  {
520    new (getStorage()) storage_type(std::forward<OtherT>(Val));
26
←
Assigned value is garbage or undefined
521  }
522 
523  /// Move construct an Expected<T> value.
524  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
525 
526  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
527  /// must be convertible to T.
528  template <class OtherT>
529  Expected(Expected<OtherT> &&Other,
530           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = 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_v<OtherT, T>> * = 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(
581      OtherT &Value,
582      std::enable_if_t<std::is_assignable_v<OtherT &, T &&>> * = 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 std::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> std::optional<T> expectedToOptional(Expected<T> &&E) {
1055  if (E)
1056    return std::move(*E);
1057  consumeError(E.takeError());
1058  return std::nullopt;
1059}
1060 
1061template <typename T> std::optional<T> expectedToStdOptional(Expected<T> &&E) {
1062  if (E)
1063    return std::move(*E);
1064  consumeError(E.takeError());
1065  return std::nullopt;
1066}
1067 
1068/// Helper for converting an Error to a bool.
1069///
1070/// This method returns true if Err is in an error state, or false if it is
1071/// in a success state.  Puts Err in a checked state in both cases (unlike
1072/// Error::operator bool(), which only does this for success states).
1073inline bool errorToBool(Error Err) {
1074  bool IsError = static_cast<bool>(Err);
1075  if (IsError)
1076    consumeError(std::move(Err));
1077  return IsError;
1078}
1079 
1080/// Helper for Errors used as out-parameters.
1081///
1082/// This helper is for use with the Error-as-out-parameter idiom, where an error
1083/// is passed to a function or method by reference, rather than being returned.
1084/// In such cases it is helpful to set the checked bit on entry to the function
1085/// so that the error can be written to (unchecked Errors abort on assignment)
1086/// and clear the checked bit on exit so that clients cannot accidentally forget
1087/// to check the result. This helper performs these actions automatically using
1088/// RAII:
1089///
1090///   @code{.cpp}
1091///   Result foo(Error &Err) {
1092///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1093///     // <body of foo>
1094///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1095///   }
1096///   @endcode
1097///
1098/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1099/// used with optional Errors (Error pointers that are allowed to be null). If
1100/// ErrorAsOutParameter took an Error reference, an instance would have to be
1101/// created inside every condition that verified that Error was non-null. By
1102/// taking an Error pointer we can just create one instance at the top of the
1103/// function.
1104class ErrorAsOutParameter {
1105public:
1106  ErrorAsOutParameter(Error *Err) : Err(Err) {
1107    // Raise the checked bit if Err is success.
1108    if (Err)
1109      (void)!!*Err;
1110  }
1111 
1112  ~ErrorAsOutParameter() {
1113    // Clear the checked bit.
1114    if (Err && !*Err)
1115      *Err = Error::success();
1116  }
1117 
1118private:
1119  Error *Err;
1120};
1121 
1122/// Helper for Expected<T>s used as out-parameters.
1123///
1124/// See ErrorAsOutParameter.
1125template <typename T>
1126class ExpectedAsOutParameter {
1127public:
1128  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1129    : ValOrErr(ValOrErr) {
1130    if (ValOrErr)
1131      (void)!!*ValOrErr;
1132  }
1133 
1134  ~ExpectedAsOutParameter() {
1135    if (ValOrErr)
1136      ValOrErr->setUnchecked();
1137  }
1138 
1139private:
1140  Expected<T> *ValOrErr;
1141};
1142 
1143/// This class wraps a std::error_code in a Error.
1144///
1145/// This is useful if you're writing an interface that returns a Error
1146/// (or Expected) and you want to call code that still returns
1147/// std::error_codes.
1148class ECError : public ErrorInfo<ECError> {
1149  friend Error errorCodeToError(std::error_code);
1150 
1151  void anchor() override;
1152 
1153public:
1154  void setErrorCode(std::error_code EC) { this->EC = EC; }
1155  std::error_code convertToErrorCode() const override { return EC; }
1156  void log(raw_ostream &OS) const override { OS << EC.message(); }
1157 
1158  // Used by ErrorInfo::classID.
1159  static char ID;
1160 
1161protected:
1162  ECError() = default;
1163  ECError(std::error_code EC) : EC(EC) {}
1164 
1165  std::error_code EC;
1166};
1167 
1168/// The value returned by this function can be returned from convertToErrorCode
1169/// for Error values where no sensible translation to std::error_code exists.
1170/// It should only be used in this situation, and should never be used where a
1171/// sensible conversion to std::error_code is available, as attempts to convert
1172/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1173/// error to try to convert such a value).
1174std::error_code inconvertibleErrorCode();
1175 
1176/// Helper for converting an std::error_code to a Error.
1177Error errorCodeToError(std::error_code EC);
1178 
1179/// Helper for converting an ECError to a std::error_code.
1180///
1181/// This method requires that Err be Error() or an ECError, otherwise it
1182/// will trigger a call to abort().
1183std::error_code errorToErrorCode(Error Err);
1184 
1185/// Convert an ErrorOr<T> to an Expected<T>.
1186template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1187  if (auto EC = EO.getError())
1188    return errorCodeToError(EC);
1189  return std::move(*EO);
1190}
1191 
1192/// Convert an Expected<T> to an ErrorOr<T>.
1193template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1194  if (auto Err = E.takeError())
1195    return errorToErrorCode(std::move(Err));
1196  return std::move(*E);
1197}
1198 
1199/// This class wraps a string in an Error.
1200///
1201/// StringError is useful in cases where the client is not expected to be able
1202/// to consume the specific error message programmatically (for example, if the
1203/// error message is to be presented to the user).
1204///
1205/// StringError can also be used when additional information is to be printed
1206/// along with a error_code message. Depending on the constructor called, this
1207/// class can either display:
1208///    1. the error_code message (ECError behavior)
1209///    2. a string
1210///    3. the error_code message and a string
1211///
1212/// These behaviors are useful when subtyping is required; for example, when a
1213/// specific library needs an explicit error type. In the example below,
1214/// PDBError is derived from StringError:
1215///
1216///   @code{.cpp}
1217///   Expected<int> foo() {
1218///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1219///                                        "Additional information");
1220///   }
1221///   @endcode
1222///
1223class StringError : public ErrorInfo<StringError> {
1224public:
1225  static char ID;
1226 
1227  // Prints EC + S and converts to EC
1228  StringError(std::error_code EC, const Twine &S = Twine());
1229 
1230  // Prints S and converts to EC
1231  StringError(const Twine &S, std::error_code EC);
1232 
1233  void log(raw_ostream &OS) const override;
1234  std::error_code convertToErrorCode() const override;
1235 
1236  const std::string &getMessage() const { return Msg; }
1237 
1238private:
1239  std::string Msg;
1240  std::error_code EC;
1241  const bool PrintMsgOnly = false;
1242};
1243 
1244/// Create formatted StringError object.
1245template <typename... Ts>
1246inline Error createStringError(std::error_code EC, char const *Fmt,
1247                               const Ts &... Vals) {
1248  std::string Buffer;
1249  raw_string_ostream Stream(Buffer);
1250  Stream << format(Fmt, Vals...);
1251  return make_error<StringError>(Stream.str(), EC);
1252}
1253 
1254Error createStringError(std::error_code EC, char const *Msg);
1255 
1256inline Error createStringError(std::error_code EC, const Twine &S) {
1257  return createStringError(EC, S.str().c_str());
1258}
1259 
1260template <typename... Ts>
1261inline Error createStringError(std::errc EC, char const *Fmt,
1262                               const Ts &... Vals) {
1263  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1264}
1265 
1266/// This class wraps a filename and another Error.
1267///
1268/// In some cases, an error needs to live along a 'source' name, in order to
1269/// show more detailed information to the user.
1270class FileError final : public ErrorInfo<FileError> {
1271 
1272  friend Error createFileError(const Twine &, Error);
1273  friend Error createFileError(const Twine &, size_t, Error);
1274 
1275public:
1276  void log(raw_ostream &OS) const override {
1277    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", 1277, __extension__ __PRETTY_FUNCTION__
));
1278    OS << "'" << FileName << "': ";
1279    if (Line)
1280      OS << "line " << *Line << ": ";
1281    Err->log(OS);
1282  }
1283 
1284  std::string messageWithoutFileInfo() const {
1285    std::string Msg;
1286    raw_string_ostream OS(Msg);
1287    Err->log(OS);
1288    return OS.str();
1289  }
1290 
1291  StringRef getFileName() const { return FileName; }
1292 
1293  Error takeError() { return Error(std::move(Err)); }
1294 
1295  std::error_code convertToErrorCode() const override;
1296 
1297  // Used by ErrorInfo::classID.
1298  static char ID;
1299 
1300private:
1301  FileError(const Twine &F, std::optional<size_t> LineNum,
1302            std::unique_ptr<ErrorInfoBase> E) {
1303    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", 1303, __extension__ __PRETTY_FUNCTION__
));
1304    FileName = F.str();
1305    Err = std::move(E);
1306    Line = std::move(LineNum);
1307  }
1308 
1309  static Error build(const Twine &F, std::optional<size_t> Line, Error E) {
1310    std::unique_ptr<ErrorInfoBase> Payload;
1311    handleAllErrors(std::move(E),
1312                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1313                      Payload = std::move(EIB);
1314                      return Error::success();
1315                    });
1316    return Error(
1317        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1318  }
1319 
1320  std::string FileName;
1321  std::optional<size_t> Line;
1322  std::unique_ptr<ErrorInfoBase> Err;
1323};
1324 
1325/// Concatenate a source file path and/or name with an Error. The resulting
1326/// Error is unchecked.
1327inline Error createFileError(const Twine &F, Error E) {
1328  return FileError::build(F, std::optional<size_t>(), std::move(E));
1329}
1330 
1331/// Concatenate a source file path and/or name with line number and an Error.
1332/// The resulting Error is unchecked.
1333inline Error createFileError(const Twine &F, size_t Line, Error E) {
1334  return FileError::build(F, std::optional<size_t>(Line), std::move(E));
1335}
1336 
1337/// Concatenate a source file path and/or name with a std::error_code 
1338/// to form an Error object.
1339inline Error createFileError(const Twine &F, std::error_code EC) {
1340  return createFileError(F, errorCodeToError(EC));
1341}
1342 
1343/// Concatenate a source file path and/or name with line number and
1344/// std::error_code to form an Error object.
1345inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1346  return createFileError(F, Line, errorCodeToError(EC));
1347}
1348 
1349Error createFileError(const Twine &F, ErrorSuccess) = delete;
1350 
1351/// Helper for check-and-exit error handling.
1352///
1353/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1354///
1355class ExitOnError {
1356public:
1357  /// Create an error on exit helper.
1358  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1359      : Banner(std::move(Banner)),
1360        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1361 
1362  /// Set the banner string for any errors caught by operator().
1363  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1364 
1365  /// Set the exit-code mapper function.
1366  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1367    this->GetExitCode = std::move(GetExitCode);
1368  }
1369 
1370  /// Check Err. If it's in a failure state log the error(s) and exit.
1371  void operator()(Error Err) const { checkError(std::move(Err)); }
1372 
1373  /// Check E. If it's in a success state then return the contained value. 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 std::move(*E);
1378  }
1379 
1380  /// Check E. If it's in a success state then return the contained reference. If
1381  /// it's in a failure state log the error(s) and exit.
1382  template <typename T> T& operator()(Expected<T&> &&E) const {
1383    checkError(E.takeError());
1384    return *E;
1385  }
1386 
1387private:
1388  void checkError(Error Err) const {
1389    if (Err) {
1390      int ExitCode = GetExitCode(Err);
1391      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1392      exit(ExitCode);
1393    }
1394  }
1395 
1396  std::string Banner;
1397  std::function<int(const Error &)> GetExitCode;
1398};
1399 
1400/// Conversion from Error to LLVMErrorRef for C error bindings.
1401inline LLVMErrorRef wrap(Error Err) {
1402  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1403}
1404 
1405/// Conversion from LLVMErrorRef to Error for C error bindings.
1406inline Error unwrap(LLVMErrorRef ErrRef) {
1407  return Error(std::unique_ptr<ErrorInfoBase>(
1408      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1409}
1410 
1411} // end namespace llvm
1412 
1413#endif // LLVM_SUPPORT_ERROR_H