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//===----------------------------------------------------------------------===//
14
15#include "llvm-jitlink.h"
16
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"
55
56#include <cstring>
57#include <deque>
58#include <list>
59#include <string>
60
61#ifdef LLVM_ON_UNIX
62#include <netdb.h>
63#include <netinet/in.h>
64#include <sys/socket.h>
65#include <unistd.h>
66#endif // LLVM_ON_UNIX
67
68#define DEBUG_TYPE "llvm_jitlink"
69
70using namespace llvm;
71using namespace llvm::jitlink;
72using namespace llvm::orc;
73
74static cl::OptionCategory JITLinkCategory("JITLink Options");
75
76static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
77                                        cl::desc("input files"),
78                                        cl::cat(JITLinkCategory));
79
80static cl::list<std::string>
81    LibrarySearchPaths("L",
82                       cl::desc("Add dir to the list of library search paths"),
83                       cl::Prefix, cl::cat(JITLinkCategory));
84
85static cl::list<std::string>
86    Libraries("l",
87              cl::desc("Link against library X in the library search paths"),
88              cl::Prefix, cl::cat(JITLinkCategory));
89
90static cl::list<std::string>
91    LibrariesHidden("hidden-l",
92                    cl::desc("Link against library X in the library search "
93                             "paths with hidden visibility"),
94                    cl::Prefix, cl::cat(JITLinkCategory));
95
96static cl::list<std::string>
97    LoadHidden("load_hidden",
98               cl::desc("Link against library X with hidden visibility"),
99               cl::cat(JITLinkCategory));
100
101static cl::opt<bool> SearchSystemLibrary(
102    "search-sys-lib",
103    cl::desc("Add system library paths to library search paths"),
104    cl::init(false), cl::cat(JITLinkCategory));
105
106static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"),
107                            cl::init(false), cl::cat(JITLinkCategory));
108
109static cl::list<std::string>
110    CheckFiles("check", cl::desc("File containing verifier checks"),
111               cl::cat(JITLinkCategory));
112
113static cl::opt<std::string>
114    CheckName("check-name", cl::desc("Name of checks to match against"),
115              cl::init("jitlink-check"), cl::cat(JITLinkCategory));
116
117static cl::opt<std::string>
118    EntryPointName("entry", cl::desc("Symbol to call as main entry point"),
119                   cl::init(""), cl::cat(JITLinkCategory));
120
121static cl::list<std::string> JITDylibs(
122    "jd",
123    cl::desc("Specifies the JITDylib to be used for any subsequent "
124             "input file, -L<seacrh-path>, and -l<library> arguments"),
125    cl::cat(JITLinkCategory));
126
127static cl::list<std::string>
128    Dylibs("preload",
129           cl::desc("Pre-load dynamic libraries (e.g. language runtimes "
130                    "required by the ORC runtime)"),
131           cl::cat(JITLinkCategory));
132
133static cl::list<std::string> InputArgv("args", cl::Positional,
134                                       cl::desc("<program arguments>..."),
135                                       cl::PositionalEatsArgs,
136                                       cl::cat(JITLinkCategory));
137
138static cl::opt<bool>
139    DebuggerSupport("debugger-support",
140                    cl::desc("Enable debugger suppport (default = !-noexec)"),
141                    cl::init(true), cl::Hidden, cl::cat(JITLinkCategory));
142
143static cl::opt<bool>
144    NoProcessSymbols("no-process-syms",
145                     cl::desc("Do not resolve to llvm-jitlink process symbols"),
146                     cl::init(false), cl::cat(JITLinkCategory));
147
148static cl::list<std::string> AbsoluteDefs(
149    "abs",
150    cl::desc("Inject absolute symbol definitions (syntax: <name>=<addr>)"),
151    cl::cat(JITLinkCategory));
152
153static cl::list<std::string>
154    Aliases("alias", cl::desc("Inject symbol aliases (syntax: <name>=<addr>)"),
155            cl::cat(JITLinkCategory));
156
157static cl::list<std::string> TestHarnesses("harness", cl::Positional,
158                                           cl::desc("Test harness files"),
159                                           cl::PositionalEatsArgs,
160                                           cl::cat(JITLinkCategory));
161
162static cl::opt<bool> ShowInitialExecutionSessionState(
163    "show-init-es",
164    cl::desc("Print ExecutionSession state before resolving entry point"),
165    cl::init(false), cl::cat(JITLinkCategory));
166
167static cl::opt<bool> ShowEntryExecutionSessionState(
168    "show-entry-es",
169    cl::desc("Print ExecutionSession state after resolving entry point"),
170    cl::init(false), cl::cat(JITLinkCategory));
171
172static cl::opt<bool> ShowAddrs(
173    "show-addrs",
174    cl::desc("Print registered symbol, section, got and stub addresses"),
175    cl::init(false), cl::cat(JITLinkCategory));
176
177static cl::opt<bool> ShowLinkGraph(
178    "show-graph",
179    cl::desc("Print the link graph after fixups have been applied"),
180    cl::init(false), cl::cat(JITLinkCategory));
181
182static cl::opt<bool> ShowSizes(
183    "show-sizes",
184    cl::desc("Show sizes pre- and post-dead stripping, and allocations"),
185    cl::init(false), cl::cat(JITLinkCategory));
186
187static cl::opt<bool> ShowTimes("show-times",
188                               cl::desc("Show times for llvm-jitlink phases"),
189                               cl::init(false), cl::cat(JITLinkCategory));
190
191static cl::opt<std::string> SlabAllocateSizeString(
192    "slab-allocate",
193    cl::desc("Allocate from a slab of the given size "
194             "(allowable suffixes: Kb, Mb, Gb. default = "
195             "Kb)"),
196    cl::init(""), cl::cat(JITLinkCategory));
197
198static cl::opt<uint64_t> SlabAddress(
199    "slab-address",
200    cl::desc("Set slab target address (requires -slab-allocate and -noexec)"),
201    cl::init(~0ULL), cl::cat(JITLinkCategory));
202
203static cl::opt<uint64_t> SlabPageSize(
204    "slab-page-size",
205    cl::desc("Set page size for slab (requires -slab-allocate and -noexec)"),
206    cl::init(0), cl::cat(JITLinkCategory));
207
208static cl::opt<bool> ShowRelocatedSectionContents(
209    "show-relocated-section-contents",
210    cl::desc("show section contents after fixups have been applied"),
211    cl::init(false), cl::cat(JITLinkCategory));
212
213static cl::opt<bool> PhonyExternals(
214    "phony-externals",
215    cl::desc("resolve all otherwise unresolved externals to null"),
216    cl::init(false), cl::cat(JITLinkCategory));
217
218static cl::opt<std::string> OutOfProcessExecutor(
219    "oop-executor", cl::desc("Launch an out-of-process executor to run code"),
220    cl::ValueOptional, cl::cat(JITLinkCategory));
221
222static cl::opt<std::string> OutOfProcessExecutorConnect(
223    "oop-executor-connect",
224    cl::desc("Connect to an out-of-process executor via TCP"),
225    cl::cat(JITLinkCategory));
226
227static cl::opt<std::string>
228    OrcRuntime("orc-runtime", cl::desc("Use ORC runtime from given path"),
229               cl::init(""), cl::cat(JITLinkCategory));
230
231static cl::opt<bool> AddSelfRelocations(
232    "add-self-relocations",
233    cl::desc("Add relocations to function pointers to the current function"),
234    cl::init(false), cl::cat(JITLinkCategory));
235
236static cl::opt<bool>
237    ShowErrFailedToMaterialize("show-err-failed-to-materialize",
238                               cl::desc("Show FailedToMaterialize errors"),
239                               cl::init(false), cl::cat(JITLinkCategory));
240
241static cl::opt<bool> UseSharedMemory(
242    "use-shared-memory",
243    cl::desc("Use shared memory to transfer generated code and data"),
244    cl::init(false), cl::cat(JITLinkCategory));
245
246static ExitOnError ExitOnErr;
247
248static LLVM_ATTRIBUTE_USED void linkComponents() {
249  errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
250         << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
251         << (void *)&llvm_orc_registerJITLoaderGDBWrapper
252         << (void *)&llvm_orc_registerJITLoaderGDBAllocAction;
253}
254
255static bool UseTestResultOverride = false;
256static int64_t TestResultOverride = 0;
257
258extern "C" LLVM_ATTRIBUTE_USED void
259llvm_jitlink_setTestResultOverride(int64_t Value) {
260  TestResultOverride = Value;
261  UseTestResultOverride = true;
262}
263
264static Error addSelfRelocations(LinkGraph &G);
265
266namespace {
267
268template <typename ErrT>
269
270class ConditionalPrintErr {
271public:
272  ConditionalPrintErr(bool C) : C(C) {}
273  void operator()(ErrT &EI) {
274    if (C) {
275      errs() << "llvm-jitlink error: ";
276      EI.log(errs());
277      errs() << "\n";
278    }
279  }
280
281private:
282  bool C;
283};
284
285Expected<std::unique_ptr<MemoryBuffer>> getFile(const Twine &FileName) {
286  if (auto F = MemoryBuffer::getFile(FileName))
287    return std::move(*F);
288  else
289    return createFileError(FileName, F.getError());
290}
291
292void reportLLVMJITLinkError(Error Err) {
293  handleAllErrors(
294      std::move(Err),
295      ConditionalPrintErr<orc::FailedToMaterialize>(ShowErrFailedToMaterialize),
296      ConditionalPrintErr<ErrorInfoBase>(true));
297}
298
299} // end anonymous namespace
300
301namespace llvm {
302
303static raw_ostream &
304operator<<(raw_ostream &OS, const Session::MemoryRegionInfo &MRI) {
305  return OS << "target addr = "
306            << format("0x%016" PRIx64, MRI.getTargetAddress())
307            << ", content: " << (const void *)MRI.getContent().data() << " -- "
308            << (const void *)(MRI.getContent().data() + MRI.getContent().size())
309            << " (" << MRI.getContent().size() << " bytes)";
310}
311
312static raw_ostream &
313operator<<(raw_ostream &OS, const Session::SymbolInfoMap &SIM) {
314  OS << "Symbols:\n";
315  for (auto &SKV : SIM)
316    OS << "  \"" << SKV.first() << "\" " << SKV.second << "\n";
317  return OS;
318}
319
320static raw_ostream &
321operator<<(raw_ostream &OS, const Session::FileInfo &FI) {
322  for (auto &SIKV : FI.SectionInfos)
323    OS << "  Section \"" << SIKV.first() << "\": " << SIKV.second << "\n";
324  for (auto &GOTKV : FI.GOTEntryInfos)
325    OS << "  GOT \"" << GOTKV.first() << "\": " << GOTKV.second << "\n";
326  for (auto &StubKV : FI.StubInfos)
327    OS << "  Stub \"" << StubKV.first() << "\": " << StubKV.second << "\n";
328  return OS;
329}
330
331static raw_ostream &
332operator<<(raw_ostream &OS, const Session::FileInfoMap &FIM) {
333  for (auto &FIKV : FIM)
334    OS << "File \"" << FIKV.first() << "\":\n" << FIKV.second;
335  return OS;
336}
337
338static Error applyHarnessPromotions(Session &S, LinkGraph &G) {
339
340  // If this graph is part of the test harness there's nothing to do.
341  if (S.HarnessFiles.empty() || S.HarnessFiles.count(G.getName()))
342    return Error::success();
343
344  LLVM_DEBUG(dbgs() << "Applying promotions to graph " << G.getName() << "\n");
345
346  // If this graph is part of the test then promote any symbols referenced by
347  // the harness to default scope, remove all symbols that clash with harness
348  // definitions.
349  std::vector<Symbol *> DefinitionsToRemove;
350  for (auto *Sym : G.defined_symbols()) {
351
352    if (!Sym->hasName())
353      continue;
354
355    if (Sym->getLinkage() == Linkage::Weak) {
356      if (!S.CanonicalWeakDefs.count(Sym->getName()) ||
357          S.CanonicalWeakDefs[Sym->getName()] != G.getName()) {
358        LLVM_DEBUG({
359          dbgs() << "  Externalizing weak symbol " << Sym->getName() << "\n";
360        });
361        DefinitionsToRemove.push_back(Sym);
362      } else {
363        LLVM_DEBUG({
364          dbgs() << "  Making weak symbol " << Sym->getName() << " strong\n";
365        });
366        if (S.HarnessExternals.count(Sym->getName()))
367          Sym->setScope(Scope::Default);
368        else
369          Sym->setScope(Scope::Hidden);
370        Sym->setLinkage(Linkage::Strong);
371      }
372    } else if (S.HarnessExternals.count(Sym->getName())) {
373      LLVM_DEBUG(dbgs() << "  Promoting " << Sym->getName() << "\n");
374      Sym->setScope(Scope::Default);
375      Sym->setLive(true);
376      continue;
377    } else if (S.HarnessDefinitions.count(Sym->getName())) {
378      LLVM_DEBUG(dbgs() << "  Externalizing " << Sym->getName() << "\n");
379      DefinitionsToRemove.push_back(Sym);
380    }
381  }
382
383  for (auto *Sym : DefinitionsToRemove)
384    G.makeExternal(*Sym);
385
386  return Error::success();
387}
388
389static uint64_t computeTotalBlockSizes(LinkGraph &G) {
390  uint64_t TotalSize = 0;
391  for (auto *B : G.blocks())
392    TotalSize += B->getSize();
393  return TotalSize;
394}
395
396static void dumpSectionContents(raw_ostream &OS, LinkGraph &G) {
397  constexpr orc::ExecutorAddrDiff DumpWidth = 16;
398  static_assert(isPowerOf2_64(DumpWidth), "DumpWidth must be a power of two");
399
400  // Put sections in address order.
401  std::vector<Section *> Sections;
402  for (auto &S : G.sections())
403    Sections.push_back(&S);
404
405  llvm::sort(Sections, [](const Section *LHS, const Section *RHS) {
406    if (LHS->symbols().empty() && RHS->symbols().empty())
407      return false;
408    if (LHS->symbols().empty())
409      return false;
410    if (RHS->symbols().empty())
411      return true;
412    SectionRange LHSRange(*LHS);
413    SectionRange RHSRange(*RHS);
414    return LHSRange.getStart() < RHSRange.getStart();
415  });
416
417  for (auto *S : Sections) {
418    OS << S->getName() << " content:";
419    if (S->symbols().empty()) {
420      OS << "\n  section empty\n";
421      continue;
422    }
423
424    // Sort symbols into order, then render.
425    std::vector<Symbol *> Syms(S->symbols().begin(), S->symbols().end());
426    llvm::sort(Syms, [](const Symbol *LHS, const Symbol *RHS) {
427      return LHS->getAddress() < RHS->getAddress();
428    });
429
430    orc::ExecutorAddr NextAddr(Syms.front()->getAddress().getValue() &
431                               ~(DumpWidth - 1));
432    for (auto *Sym : Syms) {
433      bool IsZeroFill = Sym->getBlock().isZeroFill();
434      auto SymStart = Sym->getAddress();
435      auto SymSize = Sym->getSize();
436      auto SymEnd = SymStart + SymSize;
437      const uint8_t *SymData = IsZeroFill ? nullptr
438                                          : reinterpret_cast<const uint8_t *>(
439                                                Sym->getSymbolContent().data());
440
441      // Pad any space before the symbol starts.
442      while (NextAddr != SymStart) {
443        if (NextAddr % DumpWidth == 0)
444          OS << formatv("\n{0:x16}:", NextAddr);
445        OS << "   ";
446        ++NextAddr;
447      }
448
449      // Render the symbol content.
450      while (NextAddr != SymEnd) {
451        if (NextAddr % DumpWidth == 0)
452          OS << formatv("\n{0:x16}:", NextAddr);
453        if (IsZeroFill)
454          OS << " 00";
455        else
456          OS << formatv(" {0:x-2}", SymData[NextAddr - SymStart]);
457        ++NextAddr;
458      }
459    }
460    OS << "\n";
461  }
462}
463
464// A memory mapper with a fake offset applied only used for -noexec testing
465class InProcessDeltaMapper final : public InProcessMemoryMapper {
466public:
467  InProcessDeltaMapper(size_t PageSize, uint64_t TargetAddr)
468      : InProcessMemoryMapper(PageSize), TargetMapAddr(TargetAddr),
469        DeltaAddr(0) {}
470
471  static Expected<std::unique_ptr<InProcessDeltaMapper>> Create() {
472    size_t PageSize = SlabPageSize;
473    if (!PageSize) {
474      if (auto PageSizeOrErr = sys::Process::getPageSize())
475        PageSize = *PageSizeOrErr;
476      else
477        return PageSizeOrErr.takeError();
478    }
479
480    if (PageSize == 0)
481      return make_error<StringError>("Page size is zero",
482                                     inconvertibleErrorCode());
483
484    return std::make_unique<InProcessDeltaMapper>(PageSize, SlabAddress);
485  }
486
487  void reserve(size_t NumBytes, OnReservedFunction OnReserved) override {
488    InProcessMemoryMapper::reserve(
489        NumBytes, [this, OnReserved = std::move(OnReserved)](
490                      Expected<ExecutorAddrRange> Result) mutable {
491          if (!Result)
492            return OnReserved(Result.takeError());
493
494          assert(DeltaAddr == 0 && "Overwriting previous offset");
495          if (TargetMapAddr != ~0ULL)
496            DeltaAddr = TargetMapAddr - Result->Start.getValue();
497          auto OffsetRange = ExecutorAddrRange(Result->Start + DeltaAddr,
498                                               Result->End + DeltaAddr);
499
500          OnReserved(OffsetRange);
501        });
502  }
503
504  char *prepare(ExecutorAddr Addr, size_t ContentSize) override {
505    return InProcessMemoryMapper::prepare(Addr - DeltaAddr, ContentSize);
506  }
507
508  void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override {
509    // Slide mapping based on delta and make all segments read-writable.
510    auto FixedAI = AI;
511    FixedAI.MappingBase -= DeltaAddr;
512    for (auto &Seg : FixedAI.Segments)
513      Seg.AG = AllocGroup(MemProt::Read | MemProt::Write,
514                          Seg.AG.getMemDeallocPolicy());
515    InProcessMemoryMapper::initialize(
516        FixedAI, [this, OnInitialized = std::move(OnInitialized)](
517                     Expected<ExecutorAddr> Result) mutable {
518          if (!Result)
519            return OnInitialized(Result.takeError());
520
521          OnInitialized(ExecutorAddr(Result->getValue() + DeltaAddr));
522        });
523  }
524
525  void deinitialize(ArrayRef<ExecutorAddr> Allocations,
526                    OnDeinitializedFunction OnDeInitialized) override {
527    std::vector<ExecutorAddr> Addrs(Allocations.size());
528    for (const auto Base : Allocations) {
529      Addrs.push_back(Base - DeltaAddr);
530    }
531
532    InProcessMemoryMapper::deinitialize(Addrs, std::move(OnDeInitialized));
533  }
534
535  void release(ArrayRef<ExecutorAddr> Reservations,
536               OnReleasedFunction OnRelease) override {
537    std::vector<ExecutorAddr> Addrs(Reservations.size());
538    for (const auto Base : Reservations) {
539      Addrs.push_back(Base - DeltaAddr);
540    }
541    InProcessMemoryMapper::release(Addrs, std::move(OnRelease));
542  }
543
544private:
545  uint64_t TargetMapAddr;
546  uint64_t DeltaAddr;
547};
548
549Expected<uint64_t> getSlabAllocSize(StringRef SizeString) {
550  SizeString = SizeString.trim();
551
552  uint64_t Units = 1024;
553
554  if (SizeString.endswith_insensitive("kb"))
555    SizeString = SizeString.drop_back(2).rtrim();
556  else if (SizeString.endswith_insensitive("mb")) {
557    Units = 1024 * 1024;
558    SizeString = SizeString.drop_back(2).rtrim();
559  } else if (SizeString.endswith_insensitive("gb")) {
560    Units = 1024 * 1024 * 1024;
561    SizeString = SizeString.drop_back(2).rtrim();
562  }
563
564  uint64_t SlabSize = 0;
565  if (SizeString.getAsInteger(10, SlabSize))
566    return make_error<StringError>("Invalid numeric format for slab size",
567                                   inconvertibleErrorCode());
568
569  return SlabSize * Units;
570}
571
572static std::unique_ptr<JITLinkMemoryManager> createInProcessMemoryManager() {
573  uint64_t SlabSize;
574#ifdef _WIN32
575  SlabSize = 1024 * 1024;
576#else
577  SlabSize = 1024 * 1024 * 1024;
578#endif
579
580  if (!SlabAllocateSizeString.empty())
581    SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString));
582
583  // If this is a -no-exec case and we're tweaking the slab address or size then
584  // use the delta mapper.
585  if (NoExec && (SlabAddress || SlabPageSize))
586    return ExitOnErr(
587        MapperJITLinkMemoryManager::CreateWithMapper<InProcessDeltaMapper>(
588            SlabSize));
589
590  // Otherwise use the standard in-process mapper.
591  return ExitOnErr(
592      MapperJITLinkMemoryManager::CreateWithMapper<InProcessMemoryMapper>(
593          SlabSize));
594}
595
596Expected<std::unique_ptr<jitlink::JITLinkMemoryManager>>
597createSharedMemoryManager(SimpleRemoteEPC &SREPC) {
598  SharedMemoryMapper::SymbolAddrs SAs;
599  if (auto Err = SREPC.getBootstrapSymbols(
600          {{SAs.Instance, rt::ExecutorSharedMemoryMapperServiceInstanceName},
601           {SAs.Reserve,
602            rt::ExecutorSharedMemoryMapperServiceReserveWrapperName},
603           {SAs.Initialize,
604            rt::ExecutorSharedMemoryMapperServiceInitializeWrapperName},
605           {SAs.Deinitialize,
606            rt::ExecutorSharedMemoryMapperServiceDeinitializeWrapperName},
607           {SAs.Release,
608            rt::ExecutorSharedMemoryMapperServiceReleaseWrapperName}}))
609    return std::move(Err);
610
611#ifdef _WIN32
612  size_t SlabSize = 1024 * 1024;
613#else
614  size_t SlabSize = 1024 * 1024 * 1024;
615#endif
616
617  if (!SlabAllocateSizeString.empty())
618    SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString));
619
620  return MapperJITLinkMemoryManager::CreateWithMapper<SharedMemoryMapper>(
621      SlabSize, SREPC, SAs);
622}
623
624
625static Expected<MaterializationUnit::Interface>
626getTestObjectFileInterface(Session &S, MemoryBufferRef O) {
627
628  // Get the standard interface for this object, but ignore the symbols field.
629  // We'll handle that manually to include promotion.
630  auto I = getObjectFileInterface(S.ES, O);
631  if (!I)
632    return I.takeError();
633  I->SymbolFlags.clear();
634
635  // If creating an object file was going to fail it would have happened above,
636  // so we can 'cantFail' this.
637  auto Obj = cantFail(object::ObjectFile::createObjectFile(O));
638
639  // The init symbol must be included in the SymbolFlags map if present.
640  if (I->InitSymbol)
641    I->SymbolFlags[I->InitSymbol] =
642        JITSymbolFlags::MaterializationSideEffectsOnly;
643
644  for (auto &Sym : Obj->symbols()) {
645    Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
646    if (!SymFlagsOrErr)
647      // TODO: Test this error.
648      return SymFlagsOrErr.takeError();
649
650    // Skip symbols not defined in this object file.
651    if ((*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined))
652      continue;
653
654    auto Name = Sym.getName();
655    if (!Name)
656      return Name.takeError();
657
658    // Skip symbols that have type SF_File.
659    if (auto SymType = Sym.getType()) {
660      if (*SymType == object::SymbolRef::ST_File)
661        continue;
662    } else
663      return SymType.takeError();
664
665    auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
666    if (!SymFlags)
667      return SymFlags.takeError();
668
669    if (SymFlags->isWeak()) {
670      // If this is a weak symbol that's not defined in the harness then we
671      // need to either mark it as strong (if this is the first definition
672      // that we've seen) or discard it.
673      if (S.HarnessDefinitions.count(*Name) || S.CanonicalWeakDefs.count(*Name))
674        continue;
675      S.CanonicalWeakDefs[*Name] = O.getBufferIdentifier();
676      *SymFlags &= ~JITSymbolFlags::Weak;
677      if (!S.HarnessExternals.count(*Name))
678        *SymFlags &= ~JITSymbolFlags::Exported;
679    } else if (S.HarnessExternals.count(*Name)) {
680      *SymFlags |= JITSymbolFlags::Exported;
681    } else if (S.HarnessDefinitions.count(*Name) ||
682               !(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global))
683      continue;
684
685    auto InternedName = S.ES.intern(*Name);
686    I->SymbolFlags[InternedName] = std::move(*SymFlags);
687  }
688
689  return I;
690}
691
692static Error loadProcessSymbols(Session &S) {
693  auto FilterMainEntryPoint =
694      [EPName = S.ES.intern(EntryPointName)](SymbolStringPtr Name) {
695        return Name != EPName;
696      };
697  S.MainJD->addGenerator(
698      ExitOnErr(orc::EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
699          S.ES, std::move(FilterMainEntryPoint))));
700
701  return Error::success();
702}
703
704static Error loadDylibs(Session &S) {
705  LLVM_DEBUG(dbgs() << "Loading dylibs...\n");
706  for (const auto &Dylib : Dylibs) {
707    LLVM_DEBUG(dbgs() << "  " << Dylib << "\n");
708    if (auto Err = S.loadAndLinkDynamicLibrary(*S.MainJD, Dylib))
709      return Err;
710  }
711
712  return Error::success();
713}
714
715static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() {
716#ifndef LLVM_ON_UNIX
717  // FIXME: Add support for Windows.
718  return make_error<StringError>("-" + OutOfProcessExecutor.ArgStr +
719                                     " not supported on non-unix platforms",
720                                 inconvertibleErrorCode());
721#elif !LLVM_ENABLE_THREADS
722  // Out of process mode using SimpleRemoteEPC depends on threads.
723  return make_error<StringError>(
724      "-" + OutOfProcessExecutor.ArgStr +
725          " requires threads, but LLVM was built with "
726          "LLVM_ENABLE_THREADS=Off",
727      inconvertibleErrorCode());
728#else
729
730  constexpr int ReadEnd = 0;
731  constexpr int WriteEnd = 1;
732
733  // Pipe FDs.
734  int ToExecutor[2];
735  int FromExecutor[2];
736
737  pid_t ChildPID;
738
739  // Create pipes to/from the executor..
740  if (pipe(ToExecutor) != 0 || pipe(FromExecutor) != 0)
741    return make_error<StringError>("Unable to create pipe for executor",
742                                   inconvertibleErrorCode());
743
744  ChildPID = fork();
745
746  if (ChildPID == 0) {
747    // In the child...
748
749    // Close the parent ends of the pipes
750    close(ToExecutor[WriteEnd]);
751    close(FromExecutor[ReadEnd]);
752
753    // Execute the child process.
754    std::unique_ptr<char[]> ExecutorPath, FDSpecifier;
755    {
756      ExecutorPath = std::make_unique<char[]>(OutOfProcessExecutor.size() + 1);
757      strcpy(ExecutorPath.get(), OutOfProcessExecutor.data());
758
759      std::string FDSpecifierStr("filedescs=");
760      FDSpecifierStr += utostr(ToExecutor[ReadEnd]);
761      FDSpecifierStr += ',';
762      FDSpecifierStr += utostr(FromExecutor[WriteEnd]);
763      FDSpecifier = std::make_unique<char[]>(FDSpecifierStr.size() + 1);
764      strcpy(FDSpecifier.get(), FDSpecifierStr.c_str());
765    }
766
767    char *const Args[] = {ExecutorPath.get(), FDSpecifier.get(), nullptr};
768    int RC = execvp(ExecutorPath.get(), Args);
769    if (RC != 0) {
770      errs() << "unable to launch out-of-process executor \""
771             << ExecutorPath.get() << "\"\n";
772      exit(1);
773    }
774  }
775  // else we're the parent...
776
777  // Close the child ends of the pipes
778  close(ToExecutor[ReadEnd]);
779  close(FromExecutor[WriteEnd]);
780
781  auto S = SimpleRemoteEPC::Setup();
782  if (UseSharedMemory)
783    S.CreateMemoryManager = createSharedMemoryManager;
784
785  return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
786      std::make_unique<DynamicThreadPoolTaskDispatcher>(), std::move(S),
787      FromExecutor[ReadEnd], ToExecutor[WriteEnd]);
788#endif
789}
790
791#if LLVM_ON_UNIX && LLVM_ENABLE_THREADS
792static Error createTCPSocketError(Twine Details) {
793  return make_error<StringError>(
794      formatv("Failed to connect TCP socket '{0}': {1}",
795              OutOfProcessExecutorConnect, Details),
796      inconvertibleErrorCode());
797}
798
799static Expected<int> connectTCPSocket(std::string Host, std::string PortStr) {
800  addrinfo *AI;
801  addrinfo Hints{};
802  Hints.ai_family = AF_INET;
803  Hints.ai_socktype = SOCK_STREAM;
804  Hints.ai_flags = AI_NUMERICSERV;
805
806  if (int EC = getaddrinfo(Host.c_str(), PortStr.c_str(), &Hints, &AI))
807    return createTCPSocketError("Address resolution failed (" +
808                                StringRef(gai_strerror(EC)) + ")");
809
810  // Cycle through the returned addrinfo structures and connect to the first
811  // reachable endpoint.
812  int SockFD;
813  addrinfo *Server;
814  for (Server = AI; Server != nullptr; Server = Server->ai_next) {
815    // socket might fail, e.g. if the address family is not supported. Skip to
816    // the next addrinfo structure in such a case.
817    if ((SockFD = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol)) < 0)
818      continue;
819
820    // If connect returns null, we exit the loop with a working socket.
821    if (connect(SockFD, Server->ai_addr, Server->ai_addrlen) == 0)
822      break;
823
824    close(SockFD);
825  }
826  freeaddrinfo(AI);
827
828  // If we reached the end of the loop without connecting to a valid endpoint,
829  // dump the last error that was logged in socket() or connect().
830  if (Server == nullptr)
831    return createTCPSocketError(std::strerror(errno));
832
833  return SockFD;
834}
835#endif
836
837static Expected<std::unique_ptr<ExecutorProcessControl>> connectToExecutor() {
838#ifndef LLVM_ON_UNIX
839  // FIXME: Add TCP support for Windows.
840  return make_error<StringError>("-" + OutOfProcessExecutorConnect.ArgStr +
841                                     " not supported on non-unix platforms",
842                                 inconvertibleErrorCode());
843#elif !LLVM_ENABLE_THREADS
844  // Out of process mode using SimpleRemoteEPC depends on threads.
845  return make_error<StringError>(
846      "-" + OutOfProcessExecutorConnect.ArgStr +
847          " requires threads, but LLVM was built with "
848          "LLVM_ENABLE_THREADS=Off",
849      inconvertibleErrorCode());
850#else
851
852  StringRef Host, PortStr;
853  std::tie(Host, PortStr) = StringRef(OutOfProcessExecutorConnect).split(':');
854  if (Host.empty())
855    return createTCPSocketError("Host name for -" +
856                                OutOfProcessExecutorConnect.ArgStr +
857                                " can not be empty");
858  if (PortStr.empty())
859    return createTCPSocketError("Port number in -" +
860                                OutOfProcessExecutorConnect.ArgStr +
861                                " can not be empty");
862  int Port = 0;
863  if (PortStr.getAsInteger(10, Port))
864    return createTCPSocketError("Port number '" + PortStr +
865                                "' is not a valid integer");
866
867  Expected<int> SockFD = connectTCPSocket(Host.str(), PortStr.str());
868  if (!SockFD)
869    return SockFD.takeError();
870
871  auto S = SimpleRemoteEPC::Setup();
872  if (UseSharedMemory)
873    S.CreateMemoryManager = createSharedMemoryManager;
874
875  return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>(
876      std::make_unique<DynamicThreadPoolTaskDispatcher>(),
877      std::move(S), *SockFD, *SockFD);
878#endif
879}
880
881class PhonyExternalsGenerator : public DefinitionGenerator {
882public:
883  Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
884                      JITDylibLookupFlags JDLookupFlags,
885                      const SymbolLookupSet &LookupSet) override {
886    SymbolMap PhonySymbols;
887    for (auto &KV : LookupSet)
888      PhonySymbols[KV.first] = JITEvaluatedSymbol(0, JITSymbolFlags::Exported);
889    return JD.define(absoluteSymbols(std::move(PhonySymbols)));
890  }
891};
892
893Expected<std::unique_ptr<Session>> Session::Create(Triple TT) {
894
895  std::unique_ptr<ExecutorProcessControl> EPC;
896  if (OutOfProcessExecutor.getNumOccurrences()) {
897    /// If -oop-executor is passed then launch the executor.
898    if (auto REPC = launchExecutor())
899      EPC = std::move(*REPC);
900    else
901      return REPC.takeError();
902  } else if (OutOfProcessExecutorConnect.getNumOccurrences()) {
903    /// If -oop-executor-connect is passed then connect to the executor.
904    if (auto REPC = connectToExecutor())
905      EPC = std::move(*REPC);
906    else
907      return REPC.takeError();
908  } else {
909    /// Otherwise use SelfExecutorProcessControl to target the current process.
910    auto PageSize = sys::Process::getPageSize();
911    if (!PageSize)
912      return PageSize.takeError();
913    EPC = std::make_unique<SelfExecutorProcessControl>(
914        std::make_shared<SymbolStringPool>(),
915        std::make_unique<InPlaceTaskDispatcher>(), std::move(TT), *PageSize,
916        createInProcessMemoryManager());
917  }
918
919  Error Err = Error::success();
920  std::unique_ptr<Session> S(new Session(std::move(EPC), Err));
921  if (Err)
922    return std::move(Err);
923  return std::move(S);
924}
925
926Session::~Session() {
927  if (auto Err = ES.endSession())
928    ES.reportError(std::move(Err));
929}
930
931Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err)
932    : ES(std::move(EPC)),
933      ObjLayer(ES, ES.getExecutorProcessControl().getMemMgr()) {
934
935  /// Local ObjectLinkingLayer::Plugin class to forward modifyPassConfig to the
936  /// Session.
937  class JITLinkSessionPlugin : public ObjectLinkingLayer::Plugin {
938  public:
939    JITLinkSessionPlugin(Session &S) : S(S) {}
940    void modifyPassConfig(MaterializationResponsibility &MR, LinkGraph &G,
941                          PassConfiguration &PassConfig) override {
942      S.modifyPassConfig(G.getTargetTriple(), PassConfig);
943    }
944
945    Error notifyFailed(MaterializationResponsibility &MR) override {
946      return Error::success();
947    }
948    Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
949      return Error::success();
950    }
951    void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
952                                     ResourceKey SrcKey) override {}
953
954  private:
955    Session &S;
956  };
957
958  ErrorAsOutParameter _(&Err);
959
960  ES.setErrorReporter(reportLLVMJITLinkError);
961
962  if (auto MainJDOrErr = ES.createJITDylib("main"))
963    MainJD = &*MainJDOrErr;
964  else {
965    Err = MainJDOrErr.takeError();
966    return;
967  }
968
969  if (!NoProcessSymbols)
970    ExitOnErr(loadProcessSymbols(*this));
971  else {
972    // This symbol is used in testcases.
973    auto &TestResultJD = ES.createBareJITDylib("<TestResultJD>");
974    ExitOnErr(TestResultJD.define(absoluteSymbols(
975        {{ES.intern("llvm_jitlink_setTestResultOverride"),
976          {pointerToJITTargetAddress(llvm_jitlink_setTestResultOverride),
977           JITSymbolFlags::Exported}}})));
978    MainJD->addToLinkOrder(TestResultJD);
979  }
980
981  ExitOnErr(loadDylibs(*this));
982
983  auto &TT = ES.getExecutorProcessControl().getTargetTriple();
984
985  if (DebuggerSupport && TT.isOSBinFormatMachO())
986    ObjLayer.addPlugin(ExitOnErr(
987        GDBJITDebugInfoRegistrationPlugin::Create(this->ES, *MainJD, TT)));
988
989  // Set up the platform.
990  if (TT.isOSBinFormatMachO() && !OrcRuntime.empty()) {
991    if (auto P =
992            MachOPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
993      ES.setPlatform(std::move(*P));
994    else {
995      Err = P.takeError();
996      return;
997    }
998  } else if (TT.isOSBinFormatELF() && !OrcRuntime.empty()) {
999    if (auto P =
1000            ELFNixPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str()))
1001      ES.setPlatform(std::move(*P));
1002    else {
1003      Err = P.takeError();
1004      return;
1005    }
1006  } else if (TT.isOSBinFormatCOFF() && !OrcRuntime.empty()) {
1007    auto LoadDynLibrary = [&, this](JITDylib &JD, StringRef DLLName) -> Error {
1008      if (!DLLName.endswith_insensitive(".dll"))
1009        return make_error<StringError>("DLLName not ending with .dll",
1010                                       inconvertibleErrorCode());
1011      return loadAndLinkDynamicLibrary(JD, DLLName);
1012    };
1013
1014    if (auto P = COFFPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str(),
1015                                      std::move(LoadDynLibrary)))
1016      ES.setPlatform(std::move(*P));
1017     else {
1018      Err = P.takeError();
1019      return;
1020    }
1021  } else if (TT.isOSBinFormatELF()) {
1022    if (!NoExec)
1023      ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
1024          ES, ExitOnErr(EPCEHFrameRegistrar::Create(this->ES))));
1025    if (DebuggerSupport)
1026      ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>(
1027          ES, ExitOnErr(createJITLoaderGDBRegistrar(this->ES))));
1028  }
1029
1030  ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
1031
1032  // Process any harness files.
1033  for (auto &HarnessFile : TestHarnesses) {
1034    HarnessFiles.insert(HarnessFile);
1035
1036    auto ObjBuffer = ExitOnErr(getFile(HarnessFile));
1037
1038    auto ObjInterface =
1039        ExitOnErr(getObjectFileInterface(ES, ObjBuffer->getMemBufferRef()));
1040
1041    for (auto &KV : ObjInterface.SymbolFlags)
1042      HarnessDefinitions.insert(*KV.first);
1043
1044    auto Obj = ExitOnErr(
1045        object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
1046
1047    for (auto &Sym : Obj->symbols()) {
1048      uint32_t SymFlags = ExitOnErr(Sym.getFlags());
1049      auto Name = ExitOnErr(Sym.getName());
1050
1051      if (Name.empty())
1052        continue;
1053
1054      if (SymFlags & object::BasicSymbolRef::SF_Undefined)
1055        HarnessExternals.insert(Name);
1056    }
1057  }
1058
1059  // If a name is defined by some harness file then it's a definition, not an
1060  // external.
1061  for (auto &DefName : HarnessDefinitions)
1062    HarnessExternals.erase(DefName.getKey());
1063}
1064
1065void Session::dumpSessionInfo(raw_ostream &OS) {
1066  OS << "Registered addresses:\n" << SymbolInfos << FileInfos;
1067}
1068
1069void Session::modifyPassConfig(const Triple &TT,
1070                               PassConfiguration &PassConfig) {
1071  if (!CheckFiles.empty())
1072    PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) {
1073      auto &EPC = ES.getExecutorProcessControl();
1074      if (EPC.getTargetTriple().getObjectFormat() == Triple::ELF)
1075        return registerELFGraphInfo(*this, G);
1076
1077      if (EPC.getTargetTriple().getObjectFormat() == Triple::MachO)
1078        return registerMachOGraphInfo(*this, G);
1079
1080      if (EPC.getTargetTriple().getObjectFormat() == Triple::COFF)
1081        return registerCOFFGraphInfo(*this, G);
1082
1083      return make_error<StringError>("Unsupported object format for GOT/stub "
1084                                     "registration",
1085                                     inconvertibleErrorCode());
1086    });
1087
1088  if (ShowLinkGraph)
1089    PassConfig.PostFixupPasses.push_back([](LinkGraph &G) -> Error {
1090      outs() << "Link graph \"" << G.getName() << "\" post-fixup:\n";
1091      G.dump(outs());
1092      return Error::success();
1093    });
1094
1095  PassConfig.PrePrunePasses.push_back(
1096      [this](LinkGraph &G) { return applyHarnessPromotions(*this, G); });
1097
1098  if (ShowSizes) {
1099    PassConfig.PrePrunePasses.push_back([this](LinkGraph &G) -> Error {
1100      SizeBeforePruning += computeTotalBlockSizes(G);
1101      return Error::success();
1102    });
1103    PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error {
1104      SizeAfterFixups += computeTotalBlockSizes(G);
1105      return Error::success();
1106    });
1107  }
1108
1109  if (ShowRelocatedSectionContents)
1110    PassConfig.PostFixupPasses.push_back([](LinkGraph &G) -> Error {
1111      outs() << "Relocated section contents for " << G.getName() << ":\n";
1112      dumpSectionContents(outs(), G);
1113      return Error::success();
1114    });
1115
1116  if (AddSelfRelocations)
1117    PassConfig.PostPrunePasses.push_back(addSelfRelocations);
1118}
1119
1120Expected<JITDylib *> Session::getOrLoadDynamicLibrary(StringRef LibPath) {
1121  auto It = DynLibJDs.find(LibPath.str());
1122  if (It != DynLibJDs.end()) {
1123    return It->second;
1124  }
1125  auto G = EPCDynamicLibrarySearchGenerator::Load(ES, LibPath.data());
1126  if (!G)
1127    return G.takeError();
1128  auto JD = &ES.createBareJITDylib(LibPath.str());
1129
1130  JD->addGenerator(std::move(*G));
1131  DynLibJDs.emplace(LibPath.str(), JD);
1132  LLVM_DEBUG({
1133    dbgs() << "Loaded dynamic library " << LibPath.data() << " for " << LibPath
1134           << "\n";
1135  });
1136  return JD;
1137}
1138
1139Error Session::loadAndLinkDynamicLibrary(JITDylib &JD, StringRef LibPath) {
1140  auto DL = getOrLoadDynamicLibrary(LibPath);
1141  if (!DL)
1142    return DL.takeError();
1143  JD.addToLinkOrder(**DL);
1144  LLVM_DEBUG({
1145    dbgs() << "Linking dynamic library " << LibPath << " to " << JD.getName()
1146           << "\n";
1147  });
1148  return Error::success();
1149}
1150
1151Expected<Session::FileInfo &> Session::findFileInfo(StringRef FileName) {
1152  auto FileInfoItr = FileInfos.find(FileName);
1153  if (FileInfoItr == FileInfos.end())
1154    return make_error<StringError>("file \"" + FileName + "\" not recognized",
1155                                   inconvertibleErrorCode());
1156  return FileInfoItr->second;
1157}
1158
1159Expected<Session::MemoryRegionInfo &>
1160Session::findSectionInfo(StringRef FileName, StringRef SectionName) {
1161  auto FI = findFileInfo(FileName);
1162  if (!FI)
1163    return FI.takeError();
1164  auto SecInfoItr = FI->SectionInfos.find(SectionName);
1165  if (SecInfoItr == FI->SectionInfos.end())
1166    return make_error<StringError>("no section \"" + SectionName +
1167                                       "\" registered for file \"" + FileName +
1168                                       "\"",
1169                                   inconvertibleErrorCode());
1170  return SecInfoItr->second;
1171}
1172
1173Expected<Session::MemoryRegionInfo &>
1174Session::findStubInfo(StringRef FileName, StringRef TargetName) {
1175  auto FI = findFileInfo(FileName);
1176  if (!FI)
1177    return FI.takeError();
1178  auto StubInfoItr = FI->StubInfos.find(TargetName);
1179  if (StubInfoItr == FI->StubInfos.end())
1180    return make_error<StringError>("no stub for \"" + TargetName +
1181                                       "\" registered for file \"" + FileName +
1182                                       "\"",
1183                                   inconvertibleErrorCode());
1184  return StubInfoItr->second;
1185}
1186
1187Expected<Session::MemoryRegionInfo &>
1188Session::findGOTEntryInfo(StringRef FileName, StringRef TargetName) {
1189  auto FI = findFileInfo(FileName);
1190  if (!FI)
1191    return FI.takeError();
1192  auto GOTInfoItr = FI->GOTEntryInfos.find(TargetName);
1193  if (GOTInfoItr == FI->GOTEntryInfos.end())
1194    return make_error<StringError>("no GOT entry for \"" + TargetName +
1195                                       "\" registered for file \"" + FileName +
1196                                       "\"",
1197                                   inconvertibleErrorCode());
1198  return GOTInfoItr->second;
1199}
1200
1201bool Session::isSymbolRegistered(StringRef SymbolName) {
1202  return SymbolInfos.count(SymbolName);
1203}
1204
1205Expected<Session::MemoryRegionInfo &>
1206Session::findSymbolInfo(StringRef SymbolName, Twine ErrorMsgStem) {
1207  auto SymInfoItr = SymbolInfos.find(SymbolName);
1208  if (SymInfoItr == SymbolInfos.end())
1209    return make_error<StringError>(ErrorMsgStem + ": symbol " + SymbolName +
1210                                       " not found",
1211                                   inconvertibleErrorCode());
1212  return SymInfoItr->second;
1213}
1214
1215} // end namespace llvm
1216
1217static Triple getFirstFileTriple() {
1218  static Triple FirstTT = []() {
1219    assert(!InputFiles.empty() && "InputFiles can not be empty");
1220    for (auto InputFile : InputFiles) {
1221      auto ObjBuffer = ExitOnErr(getFile(InputFile));
1222      file_magic Magic = identify_magic(ObjBuffer->getBuffer());
1223      switch (Magic) {
1224      case file_magic::coff_object:
1225      case file_magic::elf_relocatable:
1226      case file_magic::macho_object: {
1227        auto Obj = ExitOnErr(
1228            object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
1229        Triple TT = Obj->makeTriple();
1230        if (Magic == file_magic::coff_object) {
1231          // TODO: Move this to makeTriple() if possible.
1232          TT.setObjectFormat(Triple::COFF);
1233          TT.setOS(Triple::OSType::Win32);
1234        }
1235        return TT;
1236      }
1237      default:
1238        break;
1239      }
1240    }
1241    return Triple();
1242  }();
1243
1244  return FirstTT;
1245}
1246
1247static Error sanitizeArguments(const Triple &TT, const char *ArgV0) {
1248
1249  // -noexec and --args should not be used together.
1250  if (NoExec && !InputArgv.empty())
1251    errs() << "Warning: --args passed to -noexec run will be ignored.\n";
1252
1253  // Set the entry point name if not specified.
1254  if (EntryPointName.empty())
1255    EntryPointName = TT.getObjectFormat() == Triple::MachO ? "_main" : "main";
1256
1257  // Disable debugger support by default in noexec tests.
1258  if (DebuggerSupport.getNumOccurrences() == 0 && NoExec)
1259    DebuggerSupport = false;
1260
1261  // If -slab-allocate is passed, check that we're not trying to use it in
1262  // -oop-executor or -oop-executor-connect mode.
1263  //
1264  // FIXME: Remove once we enable remote slab allocation.
1265  if (SlabAllocateSizeString != "") {
1266    if (OutOfProcessExecutor.getNumOccurrences() ||
1267        OutOfProcessExecutorConnect.getNumOccurrences())
1268      return make_error<StringError>(
1269          "-slab-allocate cannot be used with -oop-executor or "
1270          "-oop-executor-connect",
1271          inconvertibleErrorCode());
1272  }
1273
1274  // If -slab-address is passed, require -slab-allocate and -noexec
1275  if (SlabAddress != ~0ULL) {
1276    if (SlabAllocateSizeString == "" || !NoExec)
1277      return make_error<StringError>(
1278          "-slab-address requires -slab-allocate and -noexec",
1279          inconvertibleErrorCode());
1280
1281    if (SlabPageSize == 0)
1282      errs() << "Warning: -slab-address used without -slab-page-size.\n";
1283  }
1284
1285  if (SlabPageSize != 0) {
1286    // -slab-page-size requires slab alloc.
1287    if (SlabAllocateSizeString == "")
1288      return make_error<StringError>("-slab-page-size requires -slab-allocate",
1289                                     inconvertibleErrorCode());
1290
1291    // Check -slab-page-size / -noexec interactions.
1292    if (!NoExec) {
1293      if (auto RealPageSize = sys::Process::getPageSize()) {
1294        if (SlabPageSize % *RealPageSize)
1295          return make_error<StringError>(
1296              "-slab-page-size must be a multiple of real page size for exec "
1297              "tests (did you mean to use -noexec ?)\n",
1298              inconvertibleErrorCode());
1299      } else {
1300        errs() << "Could not retrieve process page size:\n";
1301        logAllUnhandledErrors(RealPageSize.takeError(), errs(), "");
1302        errs() << "Executing with slab page size = "
1303               << formatv("{0:x}", SlabPageSize) << ".\n"
1304               << "Tool may crash if " << formatv("{0:x}", SlabPageSize)
1305               << " is not a multiple of the real process page size.\n"
1306               << "(did you mean to use -noexec ?)";
1307      }
1308    }
1309  }
1310
1311  // Only one of -oop-executor and -oop-executor-connect can be used.
1312  if (!!OutOfProcessExecutor.getNumOccurrences() &&
1313      !!OutOfProcessExecutorConnect.getNumOccurrences())
1314    return make_error<StringError>(
1315        "Only one of -" + OutOfProcessExecutor.ArgStr + " and -" +
1316            OutOfProcessExecutorConnect.ArgStr + " can be specified",
1317        inconvertibleErrorCode());
1318
1319  // If -oop-executor was used but no value was specified then use a sensible
1320  // default.
1321  if (!!OutOfProcessExecutor.getNumOccurrences() &&
1322      OutOfProcessExecutor.empty()) {
1323    SmallString<256> OOPExecutorPath(sys::fs::getMainExecutable(
1324        ArgV0, reinterpret_cast<void *>(&sanitizeArguments)));
1325    sys::path::remove_filename(OOPExecutorPath);
1326    sys::path::append(OOPExecutorPath, "llvm-jitlink-executor");
1327    OutOfProcessExecutor = OOPExecutorPath.str().str();
1328  }
1329
1330  return Error::success();
1331}
1332
1333static void addPhonyExternalsGenerator(Session &S) {
1334  S.MainJD->addGenerator(std::make_unique<PhonyExternalsGenerator>());
1335}
1336
1337static Error createJITDylibs(Session &S,
1338                             std::map<unsigned, JITDylib *> &IdxToJD) {
1339  // First, set up JITDylibs.
1340  LLVM_DEBUG(dbgs() << "Creating JITDylibs...\n");
1341  {
1342    // Create a "main" JITLinkDylib.
1343    IdxToJD[0] = S.MainJD;
1344    S.JDSearchOrder.push_back({S.MainJD, JITDylibLookupFlags::MatchAllSymbols});
1345    LLVM_DEBUG(dbgs() << "  0: " << S.MainJD->getName() << "\n");
1346
1347    // Add any extra JITDylibs from the command line.
1348    for (auto JDItr = JITDylibs.begin(), JDEnd = JITDylibs.end();
1349         JDItr != JDEnd; ++JDItr) {
1350      auto JD = S.ES.createJITDylib(*JDItr);
1351      if (!JD)
1352        return JD.takeError();
1353      unsigned JDIdx = JITDylibs.getPosition(JDItr - JITDylibs.begin());
1354      IdxToJD[JDIdx] = &*JD;
1355      S.JDSearchOrder.push_back({&*JD, JITDylibLookupFlags::MatchAllSymbols});
1356      LLVM_DEBUG(dbgs() << "  " << JDIdx << ": " << JD->getName() << "\n");
1357    }
1358  }
1359
1360  LLVM_DEBUG({
1361    dbgs() << "Dylib search order is [ ";
1362    for (auto &KV : S.JDSearchOrder)
1363      dbgs() << KV.first->getName() << " ";
1364    dbgs() << "]\n";
1365  });
1366
1367  return Error::success();
1368}
1369
1370static Error addAbsoluteSymbols(Session &S,
1371                                const std::map<unsigned, JITDylib *> &IdxToJD) {
1372  // Define absolute symbols.
1373  LLVM_DEBUG(dbgs() << "Defining absolute symbols...\n");
1374  for (auto AbsDefItr = AbsoluteDefs.begin(), AbsDefEnd = AbsoluteDefs.end();
1375       AbsDefItr != AbsDefEnd; ++AbsDefItr) {
1376    unsigned AbsDefArgIdx =
1377      AbsoluteDefs.getPosition(AbsDefItr - AbsoluteDefs.begin());
1378    auto &JD = *std::prev(IdxToJD.lower_bound(AbsDefArgIdx))->second;
1379
1380    StringRef AbsDefStmt = *AbsDefItr;
1381    size_t EqIdx = AbsDefStmt.find_first_of('=');
1382    if (EqIdx == StringRef::npos)
1383      return make_error<StringError>("Invalid absolute define \"" + AbsDefStmt +
1384                                     "\". Syntax: <name>=<addr>",
1385                                     inconvertibleErrorCode());
1386    StringRef Name = AbsDefStmt.substr(0, EqIdx).trim();
1387    StringRef AddrStr = AbsDefStmt.substr(EqIdx + 1).trim();
1388
1389    uint64_t Addr;
1390    if (AddrStr.getAsInteger(0, Addr))
1391      return make_error<StringError>("Invalid address expression \"" + AddrStr +
1392                                         "\" in absolute symbol definition \"" +
1393                                         AbsDefStmt + "\"",
1394                                     inconvertibleErrorCode());
1395    JITEvaluatedSymbol AbsDef(Addr, JITSymbolFlags::Exported);
1396    if (auto Err = JD.define(absoluteSymbols({{S.ES.intern(Name), AbsDef}})))
1397      return Err;
1398
1399    // Register the absolute symbol with the session symbol infos.
1400    S.SymbolInfos[Name] = {ArrayRef<char>(), Addr};
1401  }
1402
1403  return Error::success();
1404}
1405
1406static Error addAliases(Session &S,
1407                        const std::map<unsigned, JITDylib *> &IdxToJD) {
1408  // Define absolute symbols.
1409  LLVM_DEBUG(dbgs() << "Defining aliases...\n");
1410  for (auto AliasItr = Aliases.begin(), AliasEnd = Aliases.end();
1411       AliasItr != AliasEnd; ++AliasItr) {
1412    unsigned AliasArgIdx = Aliases.getPosition(AliasItr - Aliases.begin());
1413    auto &JD = *std::prev(IdxToJD.lower_bound(AliasArgIdx))->second;
1414
1415    StringRef AliasStmt = *AliasItr;
1416    size_t EqIdx = AliasStmt.find_first_of('=');
1417    if (EqIdx == StringRef::npos)
1418      return make_error<StringError>("Invalid alias definition \"" + AliasStmt +
1419                                         "\". Syntax: <name>=<addr>",
1420                                     inconvertibleErrorCode());
1421    StringRef Alias = AliasStmt.substr(0, EqIdx).trim();
1422    StringRef Aliasee = AliasStmt.substr(EqIdx + 1).trim();
1423
1424    SymbolAliasMap SAM;
1425    SAM[S.ES.intern(Alias)] = {S.ES.intern(Aliasee), JITSymbolFlags::Exported};
1426    if (auto Err = JD.define(symbolAliases(std::move(SAM))))
1427      return Err;
1428  }
1429
1430  return Error::success();
1431}
1432
1433static Error addTestHarnesses(Session &S) {
1434  LLVM_DEBUG(dbgs() << "Adding test harness objects...\n");
1435  for (auto HarnessFile : TestHarnesses) {
1436    LLVM_DEBUG(dbgs() << "  " << HarnessFile << "\n");
1437    auto ObjBuffer = getFile(HarnessFile);
1438    if (!ObjBuffer)
1439      return ObjBuffer.takeError();
1440    if (auto Err = S.ObjLayer.add(*S.MainJD, std::move(*ObjBuffer)))
1441      return Err;
1442  }
1443  return Error::success();
1444}
1445
1446static Error addObjects(Session &S,
1447                        const std::map<unsigned, JITDylib *> &IdxToJD) {
1448
1449  // Load each object into the corresponding JITDylib..
1450  LLVM_DEBUG(dbgs() << "Adding objects...\n");
1451  for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
1452       InputFileItr != InputFileEnd; ++InputFileItr) {
1453    unsigned InputFileArgIdx =
1454        InputFiles.getPosition(InputFileItr - InputFiles.begin());
1455    const std::string &InputFile = *InputFileItr;
1456    if (StringRef(InputFile).endswith(".a") ||
1457        StringRef(InputFile).endswith(".lib"))
1458      continue;
1459    auto &JD = *std::prev(IdxToJD.lower_bound(InputFileArgIdx))->second;
1460    LLVM_DEBUG(dbgs() << "  " << InputFileArgIdx << ": \"" << InputFile
1461                      << "\" to " << JD.getName() << "\n";);
1462    auto ObjBuffer = getFile(InputFile);
1463    if (!ObjBuffer)
1464      return ObjBuffer.takeError();
1465
1466    if (S.HarnessFiles.empty()) {
1467      if (auto Err = S.ObjLayer.add(JD, std::move(*ObjBuffer)))
1468        return Err;
1469    } else {
1470      // We're in -harness mode. Use a custom interface for this
1471      // test object.
1472      auto ObjInterface =
1473          getTestObjectFileInterface(S, (*ObjBuffer)->getMemBufferRef());
1474      if (!ObjInterface)
1475        return ObjInterface.takeError();
1476      if (auto Err = S.ObjLayer.add(JD, std::move(*ObjBuffer),
1477                                    std::move(*ObjInterface)))
1478        return Err;
1479    }
1480  }
1481
1482  return Error::success();
1483}
1484
1485static Expected<MaterializationUnit::Interface>
1486getObjectFileInterfaceHidden(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
1487  auto I = getObjectFileInterface(ES, ObjBuffer);
1488  if (I) {
1489    for (auto &KV : I->SymbolFlags)
1490      KV.second &= ~JITSymbolFlags::Exported;
1491  }
1492  return I;
1493}
1494
1495static SmallVector<StringRef, 5> getSearchPathsFromEnvVar(Session &S) {
1496  // FIXME: Handle EPC environment.
1497  SmallVector<StringRef, 5> PathVec;
1498  auto TT = S.ES.getExecutorProcessControl().getTargetTriple();
1499  if (TT.isOSBinFormatCOFF())
1500    StringRef(getenv("PATH")).split(PathVec, ";");
1501  else if (TT.isOSBinFormatELF())
1502    StringRef(getenv("LD_LIBRARY_PATH")).split(PathVec, ":");
1503
1504  return PathVec;
1505}
1506
1507static Error addLibraries(Session &S,
1508                          const std::map<unsigned, JITDylib *> &IdxToJD) {
1509
1510  // 1. Collect search paths for each JITDylib.
1511  DenseMap<const JITDylib *, SmallVector<StringRef, 2>> JDSearchPaths;
1512
1513  for (auto LSPItr = LibrarySearchPaths.begin(),
1514            LSPEnd = LibrarySearchPaths.end();
1515       LSPItr != LSPEnd; ++LSPItr) {
1516    unsigned LibrarySearchPathIdx =
1517        LibrarySearchPaths.getPosition(LSPItr - LibrarySearchPaths.begin());
1518    auto &JD = *std::prev(IdxToJD.lower_bound(LibrarySearchPathIdx))->second;
1519
1520    StringRef LibrarySearchPath = *LSPItr;
1521    if (sys::fs::get_file_type(LibrarySearchPath) !=
1522        sys::fs::file_type::directory_file)
1523      return make_error<StringError>("While linking " + JD.getName() + ", -L" +
1524                                         LibrarySearchPath +
1525                                         " does not point to a directory",
1526                                     inconvertibleErrorCode());
1527
1528    JDSearchPaths[&JD].push_back(*LSPItr);
1529  }
1530
1531  LLVM_DEBUG({
1532    if (!JDSearchPaths.empty())
1533      dbgs() << "Search paths:\n";
1534    for (auto &KV : JDSearchPaths) {
1535      dbgs() << "  " << KV.first->getName() << ": [";
1536      for (auto &LibSearchPath : KV.second)
1537        dbgs() << " \"" << LibSearchPath << "\"";
1538      dbgs() << " ]\n";
1539    }
1540  });
1541
1542  // 2. Collect library loads
1543  struct LibraryLoad {
1544    std::string LibName;
1545    bool IsPath = false;
1546    unsigned Position;
1547    StringRef *CandidateExtensions;
1548    enum { Standard, Hidden } Modifier;
1549  };
1550
1551  // Queue to load library as in the order as it appears in the argument list.
1552  std::deque<LibraryLoad> LibraryLoadQueue;
1553  // Add archive files from the inputs to LibraryLoads.
1554  for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
1555       InputFileItr != InputFileEnd; ++InputFileItr) {
1556    StringRef InputFile = *InputFileItr;
1557    if (!InputFile.endswith(".a") && !InputFile.endswith(".lib"))
1558      continue;
1559    LibraryLoad LL;
1560    LL.LibName = InputFile.str();
1561    LL.IsPath = true;
1562    LL.Position = InputFiles.getPosition(InputFileItr - InputFiles.begin());
1563    LL.CandidateExtensions = nullptr;
1564    LL.Modifier = LibraryLoad::Standard;
1565    LibraryLoadQueue.push_back(std::move(LL));
1566  }
1567
1568  // Add -load_hidden arguments to LibraryLoads.
1569  for (auto LibItr = LoadHidden.begin(), LibEnd = LoadHidden.end();
1570       LibItr != LibEnd; ++LibItr) {
1571    LibraryLoad LL;
1572    LL.LibName = *LibItr;
1573    LL.IsPath = true;
1574    LL.Position = LoadHidden.getPosition(LibItr - LoadHidden.begin());
1575    LL.CandidateExtensions = nullptr;
1576    LL.Modifier = LibraryLoad::Hidden;
1577    LibraryLoadQueue.push_back(std::move(LL));
1578  }
1579  StringRef StandardExtensions[] = {".so", ".dylib", ".dll", ".a", ".lib"};
1580  StringRef DynLibExtensionsOnly[] = {".so", ".dylib", ".dll"};
1581  StringRef ArchiveExtensionsOnly[] = {".a", ".lib"};
1582
1583  // Add -lx arguments to LibraryLoads.
1584  for (auto LibItr = Libraries.begin(), LibEnd = Libraries.end();
1585       LibItr != LibEnd; ++LibItr) {
1586    LibraryLoad LL;
1587    LL.LibName = *LibItr;
1588    LL.Position = Libraries.getPosition(LibItr - Libraries.begin());
1589    LL.CandidateExtensions = StandardExtensions;
1590    LL.Modifier = LibraryLoad::Standard;
1591    LibraryLoadQueue.push_back(std::move(LL));
1592  }
1593
1594  // Add -hidden-lx arguments to LibraryLoads.
1595  for (auto LibHiddenItr = LibrariesHidden.begin(),
1596            LibHiddenEnd = LibrariesHidden.end();
1597       LibHiddenItr != LibHiddenEnd; ++LibHiddenItr) {
1598    LibraryLoad LL;
1599    LL.LibName = *LibHiddenItr;
1600    LL.Position =
1601        LibrariesHidden.getPosition(LibHiddenItr - LibrariesHidden.begin());
1602    LL.CandidateExtensions = ArchiveExtensionsOnly;
1603    LL.Modifier = LibraryLoad::Hidden;
1604    LibraryLoadQueue.push_back(std::move(LL));
1605  }
1606
1607  // If there are any load-<modified> options then turn on flag overrides
1608  // to avoid flag mismatch errors.
1609  if (!LibrariesHidden.empty() || !LoadHidden.empty())
1610    S.ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
1611
1612  // Sort library loads by position in the argument list.
1613  llvm::sort(LibraryLoadQueue,
1614             [](const LibraryLoad &LHS, const LibraryLoad &RHS) {
1615               return LHS.Position < RHS.Position;
1616             });
1617
1618  // 3. Process library loads.
1619  auto AddArchive = [&](const char *Path, const LibraryLoad &LL)
1620      -> Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> {
1621    unique_function<Expected<MaterializationUnit::Interface>(
1622        ExecutionSession & ES, MemoryBufferRef ObjBuffer)>
1623        GetObjFileInterface;
1624    switch (LL.Modifier) {
1625    case LibraryLoad::Standard:
1626      GetObjFileInterface = getObjectFileInterface;
1627      break;
1628    case LibraryLoad::Hidden:
1629      GetObjFileInterface = getObjectFileInterfaceHidden;
1630      break;
1631    }
1632    auto G = StaticLibraryDefinitionGenerator::Load(
1633        S.ObjLayer, Path, S.ES.getExecutorProcessControl().getTargetTriple(),
1634        std::move(GetObjFileInterface));
1635    if (!G)
1636      return G.takeError();
1637
1638    // Push additional dynamic libraries to search.
1639    // Note that this mechanism only happens in COFF.
1640    for (auto FileName : (*G)->getImportedDynamicLibraries()) {
1641      LibraryLoad NewLL;
1642      auto FileNameRef = StringRef(FileName);
1643      if (!FileNameRef.endswith_insensitive(".dll"))
1644        return make_error<StringError>(
1645            "COFF Imported library not ending with dll extension?",
1646            inconvertibleErrorCode());
1647      NewLL.LibName = FileNameRef.drop_back(strlen(".dll")).str();
1648      NewLL.Position = LL.Position;
1649      NewLL.CandidateExtensions = DynLibExtensionsOnly;
1650      NewLL.Modifier = LibraryLoad::Standard;
1651      LibraryLoadQueue.push_front(std::move(NewLL));
1652    }
1653    return G;
1654  };
1655
1656  SmallVector<StringRef, 5> SystemSearchPaths;
1657  if (SearchSystemLibrary.getValue())
1658    SystemSearchPaths = getSearchPathsFromEnvVar(S);
1659  while (!LibraryLoadQueue.empty()) {
1660    bool LibFound = false;
1661    auto LL = LibraryLoadQueue.front();
1662    LibraryLoadQueue.pop_front();
1663    auto &JD = *std::prev(IdxToJD.lower_bound(LL.Position))->second;
1664
1665    // If this is the name of a JITDylib then link against that.
1666    if (auto *LJD = S.ES.getJITDylibByName(LL.LibName)) {
1667      JD.addToLinkOrder(*LJD);
1668      continue;
1669    }
1670
1671    if (LL.IsPath) {
1672      auto G = AddArchive(LL.LibName.c_str(), LL);
1673      if (!G)
1674        return createFileError(LL.LibName, G.takeError());
1675      JD.addGenerator(std::move(*G));
1676      LLVM_DEBUG({
1677        dbgs() << "Adding generator for static library " << LL.LibName << " to "
1678               << JD.getName() << "\n";
1679      });
1680      continue;
1681    }
1682
1683    // Otherwise look through the search paths.
1684    auto CurJDSearchPaths = JDSearchPaths[&JD];
1685    for (StringRef SearchPath :
1686         concat<StringRef>(CurJDSearchPaths, SystemSearchPaths)) {
1687      for (const char *LibExt : {".dylib", ".so", ".dll", ".a", ".lib"}) {
1688        SmallVector<char, 256> LibPath;
1689        LibPath.reserve(SearchPath.size() + strlen("lib") + LL.LibName.size() +
1690                        strlen(LibExt) + 2); // +2 for pathsep, null term.
1691        llvm::copy(SearchPath, std::back_inserter(LibPath));
1692        if (StringRef(LibExt) != ".lib" && StringRef(LibExt) != ".dll")
1693          sys::path::append(LibPath, "lib" + LL.LibName + LibExt);
1694        else
1695          sys::path::append(LibPath, LL.LibName + LibExt);
1696        LibPath.push_back('\0');
1697
1698        // Skip missing or non-regular paths.
1699        if (sys::fs::get_file_type(LibPath.data()) !=
1700            sys::fs::file_type::regular_file) {
1701          continue;
1702        }
1703
1704        file_magic Magic;
1705        if (auto EC = identify_magic(LibPath, Magic)) {
1706          // If there was an error loading the file then skip it.
1707          LLVM_DEBUG({
1708            dbgs() << "Library search found \"" << LibPath
1709                   << "\", but could not identify file type (" << EC.message()
1710                   << "). Skipping.\n";
1711          });
1712          continue;
1713        }
1714
1715        // We identified the magic. Assume that we can load it -- we'll reset
1716        // in the default case.
1717        LibFound = true;
1718        switch (Magic) {
1719        case file_magic::pecoff_executable:
1720        case file_magic::elf_shared_object:
1721        case file_magic::macho_dynamically_linked_shared_lib: {
1722          if (auto Err = S.loadAndLinkDynamicLibrary(JD, LibPath.data()))
1723            return Err;
1724          break;
1725        }
1726        case file_magic::archive:
1727        case file_magic::macho_universal_binary: {
1728          auto G = AddArchive(LibPath.data(), LL);
1729          if (!G)
1730            return G.takeError();
1731          JD.addGenerator(std::move(*G));
1732          LLVM_DEBUG({
1733            dbgs() << "Adding generator for static library " << LibPath.data()
1734                   << " to " << JD.getName() << "\n";
1735          });
1736          break;
1737        }
1738        default:
1739          // This file isn't a recognized library kind.
1740          LLVM_DEBUG({
1741            dbgs() << "Library search found \"" << LibPath
1742                   << "\", but file type is not supported. Skipping.\n";
1743          });
1744          LibFound = false;
1745          break;
1746        }
1747        if (LibFound)
1748          break;
1749      }
1750      if (LibFound)
1751        break;
1752    }
1753
1754    if (!LibFound)
1755      return make_error<StringError>("While linking " + JD.getName() +
1756                                         ", could not find library for -l" +
1757                                         LL.LibName,
1758                                     inconvertibleErrorCode());
1759  }
1760
1761  return Error::success();
1762}
1763
1764static Error addSessionInputs(Session &S) {
1765  std::map<unsigned, JITDylib *> IdxToJD;
1766
1767  if (auto Err = createJITDylibs(S, IdxToJD))
1768    return Err;
1769
1770  if (auto Err = addAbsoluteSymbols(S, IdxToJD))
1771    return Err;
1772
1773  if (auto Err = addAliases(S, IdxToJD))
1774    return Err;
1775
1776  if (!TestHarnesses.empty())
1777    if (auto Err = addTestHarnesses(S))
1778      return Err;
1779
1780  if (auto Err = addObjects(S, IdxToJD))
1781    return Err;
1782
1783  if (auto Err = addLibraries(S, IdxToJD))
1784    return Err;
1785
1786  return Error::success();
1787}
1788
1789namespace {
1790struct TargetInfo {
1791  const Target *TheTarget;
1792  std::unique_ptr<MCSubtargetInfo> STI;
1793  std::unique_ptr<MCRegisterInfo> MRI;
1794  std::unique_ptr<MCAsmInfo> MAI;
1795  std::unique_ptr<MCContext> Ctx;
1796  std::unique_ptr<MCDisassembler> Disassembler;
1797  std::unique_ptr<MCInstrInfo> MII;
1798  std::unique_ptr<MCInstrAnalysis> MIA;
1799  std::unique_ptr<MCInstPrinter> InstPrinter;
1800};
1801} // anonymous namespace
1802
1803static TargetInfo getTargetInfo(const Triple &TT) {
1804  auto TripleName = TT.str();
1805  std::string ErrorStr;
1806  const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, ErrorStr);
1807  if (!TheTarget)
1808    ExitOnErr(make_error<StringError>("Error accessing target '" + TripleName +
1809                                          "': " + ErrorStr,
1810                                      inconvertibleErrorCode()));
1811
1812  std::unique_ptr<MCSubtargetInfo> STI(
1813      TheTarget->createMCSubtargetInfo(TripleName, "", ""));
1814  if (!STI)
1815    ExitOnErr(
1816        make_error<StringError>("Unable to create subtarget for " + TripleName,
1817                                inconvertibleErrorCode()));
1818
1819  std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
1820  if (!MRI)
1821    ExitOnErr(make_error<StringError>("Unable to create target register info "
1822                                      "for " +
1823                                          TripleName,
1824                                      inconvertibleErrorCode()));
1825
1826  MCTargetOptions MCOptions;
1827  std::unique_ptr<MCAsmInfo> MAI(
1828      TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
1829  if (!MAI)
1830    ExitOnErr(make_error<StringError>("Unable to create target asm info " +
1831                                          TripleName,
1832                                      inconvertibleErrorCode()));
1833
1834  auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(),
1835                                         MRI.get(), STI.get());
1836
1837  std::unique_ptr<MCDisassembler> Disassembler(
1838      TheTarget->createMCDisassembler(*STI, *Ctx));
1839  if (!Disassembler)
1840    ExitOnErr(make_error<StringError>("Unable to create disassembler for " +
1841                                          TripleName,
1842                                      inconvertibleErrorCode()));
1843
1844  std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
1845  if (!MII)
1846    ExitOnErr(make_error<StringError>("Unable to create instruction info for" +
1847                                          TripleName,
1848                                      inconvertibleErrorCode()));
1849
1850  std::unique_ptr<MCInstrAnalysis> MIA(
1851      TheTarget->createMCInstrAnalysis(MII.get()));
1852  if (!MIA)
1853    ExitOnErr(make_error<StringError>(
1854        "Unable to create instruction analysis for" + TripleName,
1855        inconvertibleErrorCode()));
1856
1857  std::unique_ptr<MCInstPrinter> InstPrinter(
1858      TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI));
1859  if (!InstPrinter)
1860    ExitOnErr(make_error<StringError>(
1861        "Unable to create instruction printer for" + TripleName,
1862        inconvertibleErrorCode()));
1863  return {TheTarget,      std::move(STI), std::move(MRI),
1864          std::move(MAI), std::move(Ctx), std::move(Disassembler),
1865          std::move(MII), std::move(MIA), std::move(InstPrinter)};
1866}
1867
1868static Error runChecks(Session &S) {
1869  const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();
1870
1871  if (CheckFiles.empty())
1872    return Error::success();
1873
1874  LLVM_DEBUG(dbgs() << "Running checks...\n");
1875
1876  auto TI = getTargetInfo(TT);
1877
1878  auto IsSymbolValid = [&S](StringRef Symbol) {
1879    return S.isSymbolRegistered(Symbol);
1880  };
1881
1882  auto GetSymbolInfo = [&S](StringRef Symbol) {
1883    return S.findSymbolInfo(Symbol, "Can not get symbol info");
1884  };
1885
1886  auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) {
1887    return S.findSectionInfo(FileName, SectionName);
1888  };
1889
1890  auto GetStubInfo = [&S](StringRef FileName, StringRef SectionName) {
1891    return S.findStubInfo(FileName, SectionName);
1892  };
1893
1894  auto GetGOTInfo = [&S](StringRef FileName, StringRef SectionName) {
1895    return S.findGOTEntryInfo(FileName, SectionName);
1896  };
1897
1898  RuntimeDyldChecker Checker(
1899      IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo,
1900      TT.isLittleEndian() ? support::little : support::big,
1901      TI.Disassembler.get(), TI.InstPrinter.get(), dbgs());
1902
1903  std::string CheckLineStart = "# " + CheckName + ":";
1904  for (auto &CheckFile : CheckFiles) {
1905    auto CheckerFileBuf = ExitOnErr(getFile(CheckFile));
1906    if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf))
1907      ExitOnErr(make_error<StringError>(
1908          "Some checks in " + CheckFile + " failed", inconvertibleErrorCode()));
1909  }
1910
1911  return Error::success();
1912}
1913
1914static Error addSelfRelocations(LinkGraph &G) {
1915  auto TI = getTargetInfo(G.getTargetTriple());
1916  for (auto *Sym : G.defined_symbols())
1917    if (Sym->isCallable())
1918      if (auto Err = addFunctionPointerRelocationsToCurrentSymbol(
1919              *Sym, G, *TI.Disassembler, *TI.MIA))
1920        return Err;
1921  return Error::success();
1922}
1923
1924static void dumpSessionStats(Session &S) {
1925  if (!ShowSizes)
1926    return;
1927  if (!OrcRuntime.empty())
1928    outs() << "Note: Session stats include runtime and entry point lookup, but "
1929              "not JITDylib initialization/deinitialization.\n";
1930  if (ShowSizes)
1931    outs() << "  Total size of all blocks before pruning: "
1932           << S.SizeBeforePruning
1933           << "\n  Total size of all blocks after fixups: " << S.SizeAfterFixups
1934           << "\n";
1935}
1936
1937static Expected<JITEvaluatedSymbol> getMainEntryPoint(Session &S) {
1938  return S.ES.lookup(S.JDSearchOrder, S.ES.intern(EntryPointName));
1939}
1940
1941static Expected<JITEvaluatedSymbol> getOrcRuntimeEntryPoint(Session &S) {
1942  std::string RuntimeEntryPoint = "__orc_rt_run_program_wrapper";
1943  const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();
1944  if (TT.getObjectFormat() == Triple::MachO)
1945    RuntimeEntryPoint = '_' + RuntimeEntryPoint;
1946  return S.ES.lookup(S.JDSearchOrder, S.ES.intern(RuntimeEntryPoint));
1947}
1948
1949static Expected<JITEvaluatedSymbol> getEntryPoint(Session &S) {
1950  JITEvaluatedSymbol EntryPoint;
1951
1952  // Find the entry-point function unconditionally, since we want to force
1953  // it to be materialized to collect stats.
1954  if (auto EP = getMainEntryPoint(S))
1955    EntryPoint = *EP;
1956  else
1957    return EP.takeError();
1958  LLVM_DEBUG({
1959    dbgs() << "Using entry point \"" << EntryPointName
1960           << "\": " << formatv("{0:x16}", EntryPoint.getAddress()) << "\n";
1961  });
1962
1963  // If we're running with the ORC runtime then replace the entry-point
1964  // with the __orc_rt_run_program symbol.
1965  if (!OrcRuntime.empty()) {
1966    if (auto EP = getOrcRuntimeEntryPoint(S))
1967      EntryPoint = *EP;
1968    else
1969      return EP.takeError();
1970    LLVM_DEBUG({
1971      dbgs() << "(called via __orc_rt_run_program_wrapper at "
1972             << formatv("{0:x16}", EntryPoint.getAddress()) << ")\n";
1973    });
1974  }
1975
1976  return EntryPoint;
1977}
1978
1979static Expected<int> runWithRuntime(Session &S, ExecutorAddr EntryPointAddr) {
1980  StringRef DemangledEntryPoint = EntryPointName;
1981  const auto &TT = S.ES.getExecutorProcessControl().getTargetTriple();
1982  if (TT.getObjectFormat() == Triple::MachO &&
1983      DemangledEntryPoint.front() == '_')
1984    DemangledEntryPoint = DemangledEntryPoint.drop_front();
1985  using llvm::orc::shared::SPSString;
1986  using SPSRunProgramSig =
1987      int64_t(SPSString, SPSString, shared::SPSSequence<SPSString>);
1988  int64_t Result;
1989  if (auto Err = S.ES.callSPSWrapper<SPSRunProgramSig>(
1990          EntryPointAddr, Result, S.MainJD->getName(), DemangledEntryPoint,
1991          static_cast<std::vector<std::string> &>(InputArgv)))
1992    return std::move(Err);
1993  return Result;
1994}
1995
1996static Expected<int> runWithoutRuntime(Session &S,
1997                                       ExecutorAddr EntryPointAddr) {
1998  return S.ES.getExecutorProcessControl().runAsMain(EntryPointAddr, InputArgv);
1999}
2000
2001namespace {
2002struct JITLinkTimers {
2003  TimerGroup JITLinkTG{"llvm-jitlink timers", "timers for llvm-jitlink phases"};
2004  Timer LoadObjectsTimer{"load", "time to load/add object files", JITLinkTG};
2005  Timer LinkTimer{"link", "time to link object files", JITLinkTG};
2006  Timer RunTimer{"run", "time to execute jitlink'd code", JITLinkTG};
2007};
2008} // namespace
2009
2010int main(int argc, char *argv[]) {
2011  InitLLVM X(argc, argv);
2012
2013  InitializeAllTargetInfos();
2014  InitializeAllTargetMCs();
2015  InitializeAllDisassemblers();
2016
2017  cl::HideUnrelatedOptions({&JITLinkCategory, &getColorCategory()});
2018  cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool");
2019  ExitOnErr.setBanner(std::string(argv[0]) + ": ");
2020
2021  /// If timers are enabled, create a JITLinkTimers instance.
2022  std::unique_ptr<JITLinkTimers> Timers =
2023      ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
2024
2025  ExitOnErr(sanitizeArguments(getFirstFileTriple(), argv[0]));
2026
2027  auto S = ExitOnErr(Session::Create(getFirstFileTriple()));
2028
2029  {
2030    TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr);
2031    ExitOnErr(addSessionInputs(*S));
2032  }
2033
2034  if (PhonyExternals)
2035    addPhonyExternalsGenerator(*S);
2036
2037  if (ShowInitialExecutionSessionState)
2038    S->ES.dump(outs());
2039
2040  Expected<JITEvaluatedSymbol> EntryPoint(nullptr);
2041  {
2042    ExpectedAsOutParameter<JITEvaluatedSymbol> _(&EntryPoint);
2043    TimeRegion TR(Timers ? &Timers->LinkTimer : nullptr);
2044    EntryPoint = getEntryPoint(*S);
2045  }
2046
2047  // Print any reports regardless of whether we succeeded or failed.
2048  if (ShowEntryExecutionSessionState)
2049    S->ES.dump(outs());
2050
2051  if (ShowAddrs)
2052    S->dumpSessionInfo(outs());
2053
2054  dumpSessionStats(*S);
2055
2056  if (!EntryPoint) {
2057    if (Timers)
2058      Timers->JITLinkTG.printAll(errs());
2059    reportLLVMJITLinkError(EntryPoint.takeError());
2060    exit(1);
2061  }
2062
2063  ExitOnErr(runChecks(*S));
2064
2065  if (NoExec)
2066    return 0;
2067
2068  int Result = 0;
2069  {
2070    LLVM_DEBUG(dbgs() << "Running \"" << EntryPointName << "\"...\n");
2071    TimeRegion TR(Timers ? &Timers->RunTimer : nullptr);
2072    if (!OrcRuntime.empty())
2073      Result =
2074          ExitOnErr(runWithRuntime(*S, ExecutorAddr(EntryPoint->getAddress())));
2075    else
2076      Result = ExitOnErr(
2077          runWithoutRuntime(*S, ExecutorAddr(EntryPoint->getAddress())));
2078  }
2079
2080  // Destroy the session.
2081  ExitOnErr(S->ES.endSession());
2082  S.reset();
2083
2084  if (Timers)
2085    Timers->JITLinkTG.printAll(errs());
2086
2087  // If the executing code set a test result override then use that.
2088  if (UseTestResultOverride)
2089    Result = TestResultOverride;
2090
2091  return Result;
2092}
2093