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 #include "llvm/BinaryFormat/Magic.h" 17 #include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX, LLVM_ENABLE_THREADS 18 #include "llvm/ExecutionEngine/Orc/AbsoluteSymbols.h" 19 #include "llvm/ExecutionEngine/Orc/COFFPlatform.h" 20 #include "llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h" 21 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h" 22 #include "llvm/ExecutionEngine/Orc/Debugging/DebugInfoSupport.h" 23 #include "llvm/ExecutionEngine/Orc/Debugging/DebuggerSupportPlugin.h" 24 #include "llvm/ExecutionEngine/Orc/Debugging/PerfSupportPlugin.h" 25 #include "llvm/ExecutionEngine/Orc/Debugging/VTuneSupportPlugin.h" 26 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h" 27 #include "llvm/ExecutionEngine/Orc/EPCDebugObjectRegistrar.h" 28 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h" 29 #include "llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h" 30 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h" 31 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h" 32 #include "llvm/ExecutionEngine/Orc/JITLinkRedirectableSymbolManager.h" 33 #include "llvm/ExecutionEngine/Orc/JITLinkReentryTrampolines.h" 34 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h" 35 #include "llvm/ExecutionEngine/Orc/LoadLinkableFile.h" 36 #include "llvm/ExecutionEngine/Orc/MachO.h" 37 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h" 38 #include "llvm/ExecutionEngine/Orc/MapperJITLinkMemoryManager.h" 39 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.h" 40 #include "llvm/ExecutionEngine/Orc/SectCreate.h" 41 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h" 42 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h" 43 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderPerf.h" 44 #include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderVTune.h" 45 #include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h" 46 #include "llvm/MC/MCAsmInfo.h" 47 #include "llvm/MC/MCContext.h" 48 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 49 #include "llvm/MC/MCInstPrinter.h" 50 #include "llvm/MC/MCInstrAnalysis.h" 51 #include "llvm/MC/MCInstrInfo.h" 52 #include "llvm/MC/MCRegisterInfo.h" 53 #include "llvm/MC/MCSubtargetInfo.h" 54 #include "llvm/MC/MCTargetOptions.h" 55 #include "llvm/MC/TargetRegistry.h" 56 #include "llvm/Object/COFF.h" 57 #include "llvm/Object/MachO.h" 58 #include "llvm/Object/ObjectFile.h" 59 #include "llvm/Support/CommandLine.h" 60 #include "llvm/Support/Debug.h" 61 #include "llvm/Support/InitLLVM.h" 62 #include "llvm/Support/MemoryBuffer.h" 63 #include "llvm/Support/Path.h" 64 #include "llvm/Support/Process.h" 65 #include "llvm/Support/TargetSelect.h" 66 #include "llvm/Support/Timer.h" 67 #include <cstring> 68 #include <deque> 69 #include <string> 70 71 #ifdef LLVM_ON_UNIX 72 #include <netdb.h> 73 #include <netinet/in.h> 74 #include <sys/socket.h> 75 #include <unistd.h> 76 #endif // LLVM_ON_UNIX 77 78 #define DEBUG_TYPE "llvm_jitlink" 79 80 using namespace llvm; 81 using namespace llvm::jitlink; 82 using namespace llvm::orc; 83 84 static cl::OptionCategory JITLinkCategory("JITLink Options"); 85 86 static cl::list<bool> LazyLink("lazy", 87 cl::desc("Link the following file lazily"), 88 cl::cat(JITLinkCategory)); 89 90 static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore, 91 cl::desc("input files"), 92 cl::cat(JITLinkCategory)); 93 94 static cl::opt<size_t> MaterializationThreads( 95 "num-threads", cl::desc("Number of materialization threads to use"), 96 cl::init(std::numeric_limits<size_t>::max()), cl::cat(JITLinkCategory)); 97 98 static cl::list<std::string> 99 LibrarySearchPaths("L", 100 cl::desc("Add dir to the list of library search paths"), 101 cl::Prefix, cl::cat(JITLinkCategory)); 102 103 static cl::list<std::string> 104 Libraries("l", 105 cl::desc("Link against library X in the library search paths"), 106 cl::Prefix, cl::cat(JITLinkCategory)); 107 108 static cl::list<std::string> 109 LibrariesHidden("hidden-l", 110 cl::desc("Link against library X in the library search " 111 "paths with hidden visibility"), 112 cl::Prefix, cl::cat(JITLinkCategory)); 113 114 static cl::list<std::string> 115 LoadHidden("load_hidden", 116 cl::desc("Link against library X with hidden visibility"), 117 cl::cat(JITLinkCategory)); 118 119 static cl::opt<bool> SearchSystemLibrary( 120 "search-sys-lib", 121 cl::desc("Add system library paths to library search paths"), 122 cl::init(false), cl::cat(JITLinkCategory)); 123 124 static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"), 125 cl::init(false), cl::cat(JITLinkCategory)); 126 127 static cl::list<std::string> 128 CheckFiles("check", cl::desc("File containing verifier checks"), 129 cl::cat(JITLinkCategory)); 130 131 static cl::opt<std::string> 132 CheckName("check-name", cl::desc("Name of checks to match against"), 133 cl::init("jitlink-check"), cl::cat(JITLinkCategory)); 134 135 static cl::opt<std::string> 136 EntryPointName("entry", cl::desc("Symbol to call as main entry point"), 137 cl::init(""), cl::cat(JITLinkCategory)); 138 139 static cl::list<std::string> JITDylibs( 140 "jd", 141 cl::desc("Specifies the JITDylib to be used for any subsequent " 142 "input file, -L<seacrh-path>, and -l<library> arguments"), 143 cl::cat(JITLinkCategory)); 144 145 static cl::list<std::string> 146 Dylibs("preload", 147 cl::desc("Pre-load dynamic libraries (e.g. language runtimes " 148 "required by the ORC runtime)"), 149 cl::cat(JITLinkCategory)); 150 151 static cl::list<std::string> InputArgv("args", cl::Positional, 152 cl::desc("<program arguments>..."), 153 cl::PositionalEatsArgs, 154 cl::cat(JITLinkCategory)); 155 156 static cl::opt<bool> 157 DebuggerSupport("debugger-support", 158 cl::desc("Enable debugger suppport (default = !-noexec)"), 159 cl::init(true), cl::Hidden, cl::cat(JITLinkCategory)); 160 161 static cl::opt<bool> PerfSupport("perf-support", 162 cl::desc("Enable perf profiling support"), 163 cl::init(false), cl::Hidden, 164 cl::cat(JITLinkCategory)); 165 166 static cl::opt<bool> VTuneSupport("vtune-support", 167 cl::desc("Enable vtune profiling support"), 168 cl::init(false), cl::Hidden, 169 cl::cat(JITLinkCategory)); 170 static cl::opt<bool> 171 NoProcessSymbols("no-process-syms", 172 cl::desc("Do not resolve to llvm-jitlink process symbols"), 173 cl::init(false), cl::cat(JITLinkCategory)); 174 175 static cl::list<std::string> AbsoluteDefs( 176 "abs", 177 cl::desc("Inject absolute symbol definitions (syntax: <name>=<addr>)"), 178 cl::cat(JITLinkCategory)); 179 180 static cl::list<std::string> 181 Aliases("alias", 182 cl::desc("Inject symbol aliases (syntax: <alias-name>=<aliasee>)"), 183 cl::cat(JITLinkCategory)); 184 185 static cl::list<std::string> 186 SectCreate("sectcreate", 187 cl::desc("given <sectname>,<filename>[@<sym>=<offset>,...] " 188 "add the content of <filename> to <sectname>"), 189 cl::cat(JITLinkCategory)); 190 191 static cl::list<std::string> TestHarnesses("harness", cl::Positional, 192 cl::desc("Test harness files"), 193 cl::PositionalEatsArgs, 194 cl::cat(JITLinkCategory)); 195 196 static cl::opt<bool> 197 ShowLinkedFiles("show-linked-files", 198 cl::desc("List each file/graph name if/when it is linked"), 199 cl::init(false), cl::cat(JITLinkCategory)); 200 201 static cl::opt<bool> ShowInitialExecutionSessionState( 202 "show-init-es", 203 cl::desc("Print ExecutionSession state before resolving entry point"), 204 cl::init(false), cl::cat(JITLinkCategory)); 205 206 static cl::opt<bool> ShowEntryExecutionSessionState( 207 "show-entry-es", 208 cl::desc("Print ExecutionSession state after resolving entry point"), 209 cl::init(false), cl::cat(JITLinkCategory)); 210 211 static cl::opt<bool> ShowAddrs( 212 "show-addrs", 213 cl::desc("Print registered symbol, section, got and stub addresses"), 214 cl::init(false), cl::cat(JITLinkCategory)); 215 216 static cl::opt<std::string> ShowLinkGraphs( 217 "show-graphs", 218 cl::desc("Takes a posix regex and prints the link graphs of all files " 219 "matching that regex after fixups have been applied"), 220 cl::Optional, cl::cat(JITLinkCategory)); 221 222 static cl::opt<bool> ShowTimes("show-times", 223 cl::desc("Show times for llvm-jitlink phases"), 224 cl::init(false), cl::cat(JITLinkCategory)); 225 226 static cl::opt<std::string> SlabAllocateSizeString( 227 "slab-allocate", 228 cl::desc("Allocate from a slab of the given size " 229 "(allowable suffixes: Kb, Mb, Gb. default = " 230 "Kb)"), 231 cl::init(""), cl::cat(JITLinkCategory)); 232 233 static cl::opt<uint64_t> SlabAddress( 234 "slab-address", 235 cl::desc("Set slab target address (requires -slab-allocate and -noexec)"), 236 cl::init(~0ULL), cl::cat(JITLinkCategory)); 237 238 static cl::opt<uint64_t> SlabPageSize( 239 "slab-page-size", 240 cl::desc("Set page size for slab (requires -slab-allocate and -noexec)"), 241 cl::init(0), cl::cat(JITLinkCategory)); 242 243 static cl::opt<bool> ShowRelocatedSectionContents( 244 "show-relocated-section-contents", 245 cl::desc("show section contents after fixups have been applied"), 246 cl::init(false), cl::cat(JITLinkCategory)); 247 248 static cl::opt<bool> PhonyExternals( 249 "phony-externals", 250 cl::desc("resolve all otherwise unresolved externals to null"), 251 cl::init(false), cl::cat(JITLinkCategory)); 252 253 static cl::opt<std::string> OutOfProcessExecutor( 254 "oop-executor", cl::desc("Launch an out-of-process executor to run code"), 255 cl::ValueOptional, cl::cat(JITLinkCategory)); 256 257 static cl::opt<std::string> OutOfProcessExecutorConnect( 258 "oop-executor-connect", 259 cl::desc("Connect to an out-of-process executor via TCP"), 260 cl::cat(JITLinkCategory)); 261 262 static cl::opt<std::string> 263 OrcRuntime("orc-runtime", cl::desc("Use ORC runtime from given path"), 264 cl::init(""), cl::cat(JITLinkCategory)); 265 266 static cl::opt<bool> AddSelfRelocations( 267 "add-self-relocations", 268 cl::desc("Add relocations to function pointers to the current function"), 269 cl::init(false), cl::cat(JITLinkCategory)); 270 271 static cl::opt<bool> 272 ShowErrFailedToMaterialize("show-err-failed-to-materialize", 273 cl::desc("Show FailedToMaterialize errors"), 274 cl::init(false), cl::cat(JITLinkCategory)); 275 276 static cl::opt<bool> UseSharedMemory( 277 "use-shared-memory", 278 cl::desc("Use shared memory to transfer generated code and data"), 279 cl::init(false), cl::cat(JITLinkCategory)); 280 281 static cl::opt<std::string> 282 OverrideTriple("triple", cl::desc("Override target triple detection"), 283 cl::init(""), cl::cat(JITLinkCategory)); 284 285 static cl::opt<bool> AllLoad("all_load", 286 cl::desc("Load all members of static archives"), 287 cl::init(false), cl::cat(JITLinkCategory)); 288 289 static cl::opt<bool> ForceLoadObjC( 290 "ObjC", 291 cl::desc("Load all members of static archives that implement " 292 "Objective-C classes or categories, or Swift structs, " 293 "classes or extensions"), 294 cl::init(false), cl::cat(JITLinkCategory)); 295 296 static ExitOnError ExitOnErr; 297 298 static LLVM_ATTRIBUTE_USED void linkComponents() { 299 errs() << "Linking in runtime functions\n" 300 << (void *)&llvm_orc_registerEHFrameSectionWrapper << '\n' 301 << (void *)&llvm_orc_deregisterEHFrameSectionWrapper << '\n' 302 << (void *)&llvm_orc_registerJITLoaderGDBWrapper << '\n' 303 << (void *)&llvm_orc_registerJITLoaderGDBAllocAction << '\n' 304 << (void *)&llvm_orc_registerJITLoaderPerfStart << '\n' 305 << (void *)&llvm_orc_registerJITLoaderPerfEnd << '\n' 306 << (void *)&llvm_orc_registerJITLoaderPerfImpl << '\n' 307 << (void *)&llvm_orc_registerVTuneImpl << '\n' 308 << (void *)&llvm_orc_unregisterVTuneImpl << '\n' 309 << (void *)&llvm_orc_test_registerVTuneImpl << '\n'; 310 } 311 312 static bool UseTestResultOverride = false; 313 static int64_t TestResultOverride = 0; 314 315 extern "C" LLVM_ATTRIBUTE_USED void 316 llvm_jitlink_setTestResultOverride(int64_t Value) { 317 TestResultOverride = Value; 318 UseTestResultOverride = true; 319 } 320 321 static Error addSelfRelocations(LinkGraph &G); 322 323 namespace { 324 325 template <typename ErrT> 326 327 class ConditionalPrintErr { 328 public: 329 ConditionalPrintErr(bool C) : C(C) {} 330 void operator()(ErrT &EI) { 331 if (C) { 332 errs() << "llvm-jitlink error: "; 333 EI.log(errs()); 334 errs() << "\n"; 335 } 336 } 337 338 private: 339 bool C; 340 }; 341 342 Expected<std::unique_ptr<MemoryBuffer>> getFile(const Twine &FileName) { 343 if (auto F = MemoryBuffer::getFile(FileName)) 344 return std::move(*F); 345 else 346 return createFileError(FileName, F.getError()); 347 } 348 349 void reportLLVMJITLinkError(Error Err) { 350 handleAllErrors( 351 std::move(Err), 352 ConditionalPrintErr<orc::FailedToMaterialize>(ShowErrFailedToMaterialize), 353 ConditionalPrintErr<ErrorInfoBase>(true)); 354 } 355 356 } // end anonymous namespace 357 358 namespace llvm { 359 360 static raw_ostream & 361 operator<<(raw_ostream &OS, const Session::MemoryRegionInfo &MRI) { 362 return OS << "target addr = " 363 << format("0x%016" PRIx64, MRI.getTargetAddress()) 364 << ", content: " << (const void *)MRI.getContent().data() << " -- " 365 << (const void *)(MRI.getContent().data() + MRI.getContent().size()) 366 << " (" << MRI.getContent().size() << " bytes)"; 367 } 368 369 static raw_ostream & 370 operator<<(raw_ostream &OS, const Session::SymbolInfoMap &SIM) { 371 OS << "Symbols:\n"; 372 for (auto &SKV : SIM) 373 OS << " \"" << SKV.first << "\" " << SKV.second << "\n"; 374 return OS; 375 } 376 377 static raw_ostream & 378 operator<<(raw_ostream &OS, const Session::FileInfo &FI) { 379 for (auto &SIKV : FI.SectionInfos) 380 OS << " Section \"" << SIKV.first() << "\": " << SIKV.second << "\n"; 381 for (auto &GOTKV : FI.GOTEntryInfos) 382 OS << " GOT \"" << GOTKV.first() << "\": " << GOTKV.second << "\n"; 383 for (auto &StubKVs : FI.StubInfos) { 384 OS << " Stubs \"" << StubKVs.first() << "\":"; 385 for (auto MemRegion : StubKVs.second) 386 OS << " " << MemRegion; 387 OS << "\n"; 388 } 389 return OS; 390 } 391 392 static raw_ostream & 393 operator<<(raw_ostream &OS, const Session::FileInfoMap &FIM) { 394 for (auto &FIKV : FIM) 395 OS << "File \"" << FIKV.first() << "\":\n" << FIKV.second; 396 return OS; 397 } 398 399 bool lazyLinkingRequested() { 400 for (auto LL : LazyLink) 401 if (LL) 402 return true; 403 return false; 404 } 405 406 static Error applyHarnessPromotions(Session &S, LinkGraph &G) { 407 std::lock_guard<std::mutex> Lock(S.M); 408 409 // If this graph is part of the test harness there's nothing to do. 410 if (S.HarnessFiles.empty() || S.HarnessFiles.count(G.getName())) 411 return Error::success(); 412 413 LLVM_DEBUG(dbgs() << "Applying promotions to graph " << G.getName() << "\n"); 414 415 // If this graph is part of the test then promote any symbols referenced by 416 // the harness to default scope, remove all symbols that clash with harness 417 // definitions. 418 std::vector<Symbol *> DefinitionsToRemove; 419 for (auto *Sym : G.defined_symbols()) { 420 421 if (!Sym->hasName()) 422 continue; 423 424 if (Sym->getLinkage() == Linkage::Weak) { 425 if (!S.CanonicalWeakDefs.count(*Sym->getName()) || 426 S.CanonicalWeakDefs[*Sym->getName()] != G.getName()) { 427 LLVM_DEBUG({ 428 dbgs() << " Externalizing weak symbol " << Sym->getName() << "\n"; 429 }); 430 DefinitionsToRemove.push_back(Sym); 431 } else { 432 LLVM_DEBUG({ 433 dbgs() << " Making weak symbol " << Sym->getName() << " strong\n"; 434 }); 435 if (S.HarnessExternals.count(*Sym->getName())) 436 Sym->setScope(Scope::Default); 437 else 438 Sym->setScope(Scope::Hidden); 439 Sym->setLinkage(Linkage::Strong); 440 } 441 } else if (S.HarnessExternals.count(*Sym->getName())) { 442 LLVM_DEBUG(dbgs() << " Promoting " << Sym->getName() << "\n"); 443 Sym->setScope(Scope::Default); 444 Sym->setLive(true); 445 continue; 446 } else if (S.HarnessDefinitions.count(*Sym->getName())) { 447 LLVM_DEBUG(dbgs() << " Externalizing " << Sym->getName() << "\n"); 448 DefinitionsToRemove.push_back(Sym); 449 } 450 } 451 452 for (auto *Sym : DefinitionsToRemove) 453 G.makeExternal(*Sym); 454 455 return Error::success(); 456 } 457 458 static void dumpSectionContents(raw_ostream &OS, Session &S, LinkGraph &G) { 459 std::lock_guard<std::mutex> Lock(S.M); 460 461 outs() << "Relocated section contents for " << G.getName() << ":\n"; 462 463 constexpr orc::ExecutorAddrDiff DumpWidth = 16; 464 static_assert(isPowerOf2_64(DumpWidth), "DumpWidth must be a power of two"); 465 466 // Put sections in address order. 467 std::vector<Section *> Sections; 468 for (auto &S : G.sections()) 469 Sections.push_back(&S); 470 471 llvm::sort(Sections, [](const Section *LHS, const Section *RHS) { 472 if (LHS->symbols().empty() && RHS->symbols().empty()) 473 return false; 474 if (LHS->symbols().empty()) 475 return false; 476 if (RHS->symbols().empty()) 477 return true; 478 SectionRange LHSRange(*LHS); 479 SectionRange RHSRange(*RHS); 480 return LHSRange.getStart() < RHSRange.getStart(); 481 }); 482 483 for (auto *S : Sections) { 484 OS << S->getName() << " content:"; 485 if (S->symbols().empty()) { 486 OS << "\n section empty\n"; 487 continue; 488 } 489 490 // Sort symbols into order, then render. 491 std::vector<Symbol *> Syms(S->symbols().begin(), S->symbols().end()); 492 llvm::sort(Syms, [](const Symbol *LHS, const Symbol *RHS) { 493 return LHS->getAddress() < RHS->getAddress(); 494 }); 495 496 orc::ExecutorAddr NextAddr(Syms.front()->getAddress().getValue() & 497 ~(DumpWidth - 1)); 498 for (auto *Sym : Syms) { 499 bool IsZeroFill = Sym->getBlock().isZeroFill(); 500 auto SymStart = Sym->getAddress(); 501 auto SymSize = Sym->getSize(); 502 auto SymEnd = SymStart + SymSize; 503 const uint8_t *SymData = IsZeroFill ? nullptr 504 : reinterpret_cast<const uint8_t *>( 505 Sym->getSymbolContent().data()); 506 507 // Pad any space before the symbol starts. 508 while (NextAddr != SymStart) { 509 if (NextAddr % DumpWidth == 0) 510 OS << formatv("\n{0:x16}:", NextAddr); 511 OS << " "; 512 ++NextAddr; 513 } 514 515 // Render the symbol content. 516 while (NextAddr != SymEnd) { 517 if (NextAddr % DumpWidth == 0) 518 OS << formatv("\n{0:x16}:", NextAddr); 519 if (IsZeroFill) 520 OS << " 00"; 521 else 522 OS << formatv(" {0:x-2}", SymData[NextAddr - SymStart]); 523 ++NextAddr; 524 } 525 } 526 OS << "\n"; 527 } 528 } 529 530 // A memory mapper with a fake offset applied only used for -noexec testing 531 class InProcessDeltaMapper final : public InProcessMemoryMapper { 532 public: 533 InProcessDeltaMapper(size_t PageSize, uint64_t TargetAddr) 534 : InProcessMemoryMapper(PageSize), TargetMapAddr(TargetAddr), 535 DeltaAddr(0) {} 536 537 static Expected<std::unique_ptr<InProcessDeltaMapper>> Create() { 538 size_t PageSize = SlabPageSize; 539 if (!PageSize) { 540 if (auto PageSizeOrErr = sys::Process::getPageSize()) 541 PageSize = *PageSizeOrErr; 542 else 543 return PageSizeOrErr.takeError(); 544 } 545 546 if (PageSize == 0) 547 return make_error<StringError>("Page size is zero", 548 inconvertibleErrorCode()); 549 550 return std::make_unique<InProcessDeltaMapper>(PageSize, SlabAddress); 551 } 552 553 void reserve(size_t NumBytes, OnReservedFunction OnReserved) override { 554 InProcessMemoryMapper::reserve( 555 NumBytes, [this, OnReserved = std::move(OnReserved)]( 556 Expected<ExecutorAddrRange> Result) mutable { 557 if (!Result) 558 return OnReserved(Result.takeError()); 559 560 assert(DeltaAddr == 0 && "Overwriting previous offset"); 561 if (TargetMapAddr != ~0ULL) 562 DeltaAddr = TargetMapAddr - Result->Start.getValue(); 563 auto OffsetRange = ExecutorAddrRange(Result->Start + DeltaAddr, 564 Result->End + DeltaAddr); 565 566 OnReserved(OffsetRange); 567 }); 568 } 569 570 char *prepare(ExecutorAddr Addr, size_t ContentSize) override { 571 return InProcessMemoryMapper::prepare(Addr - DeltaAddr, ContentSize); 572 } 573 574 void initialize(AllocInfo &AI, OnInitializedFunction OnInitialized) override { 575 // Slide mapping based on delta, make all segments read-writable, and 576 // discard allocation actions. 577 auto FixedAI = std::move(AI); 578 FixedAI.MappingBase -= DeltaAddr; 579 for (auto &Seg : FixedAI.Segments) 580 Seg.AG = {MemProt::Read | MemProt::Write, Seg.AG.getMemLifetime()}; 581 FixedAI.Actions.clear(); 582 InProcessMemoryMapper::initialize( 583 FixedAI, [this, OnInitialized = std::move(OnInitialized)]( 584 Expected<ExecutorAddr> Result) mutable { 585 if (!Result) 586 return OnInitialized(Result.takeError()); 587 588 OnInitialized(ExecutorAddr(Result->getValue() + DeltaAddr)); 589 }); 590 } 591 592 void deinitialize(ArrayRef<ExecutorAddr> Allocations, 593 OnDeinitializedFunction OnDeInitialized) override { 594 std::vector<ExecutorAddr> Addrs(Allocations.size()); 595 for (const auto Base : Allocations) { 596 Addrs.push_back(Base - DeltaAddr); 597 } 598 599 InProcessMemoryMapper::deinitialize(Addrs, std::move(OnDeInitialized)); 600 } 601 602 void release(ArrayRef<ExecutorAddr> Reservations, 603 OnReleasedFunction OnRelease) override { 604 std::vector<ExecutorAddr> Addrs(Reservations.size()); 605 for (const auto Base : Reservations) { 606 Addrs.push_back(Base - DeltaAddr); 607 } 608 InProcessMemoryMapper::release(Addrs, std::move(OnRelease)); 609 } 610 611 private: 612 uint64_t TargetMapAddr; 613 uint64_t DeltaAddr; 614 }; 615 616 Expected<uint64_t> getSlabAllocSize(StringRef SizeString) { 617 SizeString = SizeString.trim(); 618 619 uint64_t Units = 1024; 620 621 if (SizeString.ends_with_insensitive("kb")) 622 SizeString = SizeString.drop_back(2).rtrim(); 623 else if (SizeString.ends_with_insensitive("mb")) { 624 Units = 1024 * 1024; 625 SizeString = SizeString.drop_back(2).rtrim(); 626 } else if (SizeString.ends_with_insensitive("gb")) { 627 Units = 1024 * 1024 * 1024; 628 SizeString = SizeString.drop_back(2).rtrim(); 629 } 630 631 uint64_t SlabSize = 0; 632 if (SizeString.getAsInteger(10, SlabSize)) 633 return make_error<StringError>("Invalid numeric format for slab size", 634 inconvertibleErrorCode()); 635 636 return SlabSize * Units; 637 } 638 639 static std::unique_ptr<JITLinkMemoryManager> createInProcessMemoryManager() { 640 uint64_t SlabSize; 641 #ifdef _WIN32 642 SlabSize = 1024 * 1024; 643 #else 644 SlabSize = 1024 * 1024 * 1024; 645 #endif 646 647 if (!SlabAllocateSizeString.empty()) 648 SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString)); 649 650 // If this is a -no-exec case and we're tweaking the slab address or size then 651 // use the delta mapper. 652 if (NoExec && (SlabAddress || SlabPageSize)) 653 return ExitOnErr( 654 MapperJITLinkMemoryManager::CreateWithMapper<InProcessDeltaMapper>( 655 SlabSize)); 656 657 // Otherwise use the standard in-process mapper. 658 return ExitOnErr( 659 MapperJITLinkMemoryManager::CreateWithMapper<InProcessMemoryMapper>( 660 SlabSize)); 661 } 662 663 Expected<std::unique_ptr<jitlink::JITLinkMemoryManager>> 664 createSharedMemoryManager(SimpleRemoteEPC &SREPC) { 665 SharedMemoryMapper::SymbolAddrs SAs; 666 if (auto Err = SREPC.getBootstrapSymbols( 667 {{SAs.Instance, rt::ExecutorSharedMemoryMapperServiceInstanceName}, 668 {SAs.Reserve, 669 rt::ExecutorSharedMemoryMapperServiceReserveWrapperName}, 670 {SAs.Initialize, 671 rt::ExecutorSharedMemoryMapperServiceInitializeWrapperName}, 672 {SAs.Deinitialize, 673 rt::ExecutorSharedMemoryMapperServiceDeinitializeWrapperName}, 674 {SAs.Release, 675 rt::ExecutorSharedMemoryMapperServiceReleaseWrapperName}})) 676 return std::move(Err); 677 678 #ifdef _WIN32 679 size_t SlabSize = 1024 * 1024; 680 #else 681 size_t SlabSize = 1024 * 1024 * 1024; 682 #endif 683 684 if (!SlabAllocateSizeString.empty()) 685 SlabSize = ExitOnErr(getSlabAllocSize(SlabAllocateSizeString)); 686 687 return MapperJITLinkMemoryManager::CreateWithMapper<SharedMemoryMapper>( 688 SlabSize, SREPC, SAs); 689 } 690 691 692 static Expected<MaterializationUnit::Interface> 693 getTestObjectFileInterface(Session &S, MemoryBufferRef O) { 694 695 // Get the standard interface for this object, but ignore the symbols field. 696 // We'll handle that manually to include promotion. 697 auto I = getObjectFileInterface(S.ES, O); 698 if (!I) 699 return I.takeError(); 700 I->SymbolFlags.clear(); 701 702 // If creating an object file was going to fail it would have happened above, 703 // so we can 'cantFail' this. 704 auto Obj = cantFail(object::ObjectFile::createObjectFile(O)); 705 706 // The init symbol must be included in the SymbolFlags map if present. 707 if (I->InitSymbol) 708 I->SymbolFlags[I->InitSymbol] = 709 JITSymbolFlags::MaterializationSideEffectsOnly; 710 711 for (auto &Sym : Obj->symbols()) { 712 Expected<uint32_t> SymFlagsOrErr = Sym.getFlags(); 713 if (!SymFlagsOrErr) 714 // TODO: Test this error. 715 return SymFlagsOrErr.takeError(); 716 717 // Skip symbols not defined in this object file. 718 if ((*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined)) 719 continue; 720 721 auto Name = Sym.getName(); 722 if (!Name) 723 return Name.takeError(); 724 725 // Skip symbols that have type SF_File. 726 if (auto SymType = Sym.getType()) { 727 if (*SymType == object::SymbolRef::ST_File) 728 continue; 729 } else 730 return SymType.takeError(); 731 732 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym); 733 if (!SymFlags) 734 return SymFlags.takeError(); 735 736 if (SymFlags->isWeak()) { 737 // If this is a weak symbol that's not defined in the harness then we 738 // need to either mark it as strong (if this is the first definition 739 // that we've seen) or discard it. 740 if (S.HarnessDefinitions.count(*Name) || S.CanonicalWeakDefs.count(*Name)) 741 continue; 742 S.CanonicalWeakDefs[*Name] = O.getBufferIdentifier(); 743 *SymFlags &= ~JITSymbolFlags::Weak; 744 if (!S.HarnessExternals.count(*Name)) 745 *SymFlags &= ~JITSymbolFlags::Exported; 746 } else if (S.HarnessExternals.count(*Name)) { 747 *SymFlags |= JITSymbolFlags::Exported; 748 } else if (S.HarnessDefinitions.count(*Name) || 749 !(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) 750 continue; 751 752 I->SymbolFlags[S.ES.intern(*Name)] = std::move(*SymFlags); 753 } 754 755 return I; 756 } 757 758 static Error loadProcessSymbols(Session &S) { 759 S.ProcessSymsJD = &S.ES.createBareJITDylib("Process"); 760 auto FilterMainEntryPoint = 761 [EPName = S.ES.intern(EntryPointName)](SymbolStringPtr Name) { 762 return Name != EPName; 763 }; 764 S.ProcessSymsJD->addGenerator( 765 ExitOnErr(orc::EPCDynamicLibrarySearchGenerator::GetForTargetProcess( 766 S.ES, std::move(FilterMainEntryPoint)))); 767 768 return Error::success(); 769 } 770 771 static Error loadDylibs(Session &S) { 772 LLVM_DEBUG(dbgs() << "Loading dylibs...\n"); 773 for (const auto &Dylib : Dylibs) { 774 LLVM_DEBUG(dbgs() << " " << Dylib << "\n"); 775 auto DL = S.getOrLoadDynamicLibrary(Dylib); 776 if (!DL) 777 return DL.takeError(); 778 } 779 780 return Error::success(); 781 } 782 783 static Expected<std::unique_ptr<ExecutorProcessControl>> launchExecutor() { 784 #ifndef LLVM_ON_UNIX 785 // FIXME: Add support for Windows. 786 return make_error<StringError>("-" + OutOfProcessExecutor.ArgStr + 787 " not supported on non-unix platforms", 788 inconvertibleErrorCode()); 789 #elif !LLVM_ENABLE_THREADS 790 // Out of process mode using SimpleRemoteEPC depends on threads. 791 return make_error<StringError>( 792 "-" + OutOfProcessExecutor.ArgStr + 793 " requires threads, but LLVM was built with " 794 "LLVM_ENABLE_THREADS=Off", 795 inconvertibleErrorCode()); 796 #else 797 798 constexpr int ReadEnd = 0; 799 constexpr int WriteEnd = 1; 800 801 // Pipe FDs. 802 int ToExecutor[2]; 803 int FromExecutor[2]; 804 805 pid_t ChildPID; 806 807 // Create pipes to/from the executor.. 808 if (pipe(ToExecutor) != 0 || pipe(FromExecutor) != 0) 809 return make_error<StringError>("Unable to create pipe for executor", 810 inconvertibleErrorCode()); 811 812 ChildPID = fork(); 813 814 if (ChildPID == 0) { 815 // In the child... 816 817 // Close the parent ends of the pipes 818 close(ToExecutor[WriteEnd]); 819 close(FromExecutor[ReadEnd]); 820 821 // Execute the child process. 822 std::unique_ptr<char[]> ExecutorPath, FDSpecifier; 823 { 824 ExecutorPath = std::make_unique<char[]>(OutOfProcessExecutor.size() + 1); 825 strcpy(ExecutorPath.get(), OutOfProcessExecutor.data()); 826 827 std::string FDSpecifierStr("filedescs="); 828 FDSpecifierStr += utostr(ToExecutor[ReadEnd]); 829 FDSpecifierStr += ','; 830 FDSpecifierStr += utostr(FromExecutor[WriteEnd]); 831 FDSpecifier = std::make_unique<char[]>(FDSpecifierStr.size() + 1); 832 strcpy(FDSpecifier.get(), FDSpecifierStr.c_str()); 833 } 834 835 char *const Args[] = {ExecutorPath.get(), FDSpecifier.get(), nullptr}; 836 int RC = execvp(ExecutorPath.get(), Args); 837 if (RC != 0) { 838 errs() << "unable to launch out-of-process executor \"" 839 << ExecutorPath.get() << "\"\n"; 840 exit(1); 841 } 842 } 843 // else we're the parent... 844 845 // Close the child ends of the pipes 846 close(ToExecutor[ReadEnd]); 847 close(FromExecutor[WriteEnd]); 848 849 auto S = SimpleRemoteEPC::Setup(); 850 if (UseSharedMemory) 851 S.CreateMemoryManager = createSharedMemoryManager; 852 853 return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>( 854 std::make_unique<DynamicThreadPoolTaskDispatcher>(MaterializationThreads), 855 std::move(S), FromExecutor[ReadEnd], ToExecutor[WriteEnd]); 856 #endif 857 } 858 859 #if LLVM_ON_UNIX && LLVM_ENABLE_THREADS 860 static Error createTCPSocketError(Twine Details) { 861 return make_error<StringError>( 862 formatv("Failed to connect TCP socket '{0}': {1}", 863 OutOfProcessExecutorConnect, Details), 864 inconvertibleErrorCode()); 865 } 866 867 static Expected<int> connectTCPSocket(std::string Host, std::string PortStr) { 868 addrinfo *AI; 869 addrinfo Hints{}; 870 Hints.ai_family = AF_INET; 871 Hints.ai_socktype = SOCK_STREAM; 872 Hints.ai_flags = AI_NUMERICSERV; 873 874 if (int EC = getaddrinfo(Host.c_str(), PortStr.c_str(), &Hints, &AI)) 875 return createTCPSocketError("Address resolution failed (" + 876 StringRef(gai_strerror(EC)) + ")"); 877 878 // Cycle through the returned addrinfo structures and connect to the first 879 // reachable endpoint. 880 int SockFD; 881 addrinfo *Server; 882 for (Server = AI; Server != nullptr; Server = Server->ai_next) { 883 // socket might fail, e.g. if the address family is not supported. Skip to 884 // the next addrinfo structure in such a case. 885 if ((SockFD = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol)) < 0) 886 continue; 887 888 // If connect returns null, we exit the loop with a working socket. 889 if (connect(SockFD, Server->ai_addr, Server->ai_addrlen) == 0) 890 break; 891 892 close(SockFD); 893 } 894 freeaddrinfo(AI); 895 896 // If we reached the end of the loop without connecting to a valid endpoint, 897 // dump the last error that was logged in socket() or connect(). 898 if (Server == nullptr) 899 return createTCPSocketError(std::strerror(errno)); 900 901 return SockFD; 902 } 903 #endif 904 905 static Expected<std::unique_ptr<ExecutorProcessControl>> connectToExecutor() { 906 #ifndef LLVM_ON_UNIX 907 // FIXME: Add TCP support for Windows. 908 return make_error<StringError>("-" + OutOfProcessExecutorConnect.ArgStr + 909 " not supported on non-unix platforms", 910 inconvertibleErrorCode()); 911 #elif !LLVM_ENABLE_THREADS 912 // Out of process mode using SimpleRemoteEPC depends on threads. 913 return make_error<StringError>( 914 "-" + OutOfProcessExecutorConnect.ArgStr + 915 " requires threads, but LLVM was built with " 916 "LLVM_ENABLE_THREADS=Off", 917 inconvertibleErrorCode()); 918 #else 919 920 StringRef Host, PortStr; 921 std::tie(Host, PortStr) = StringRef(OutOfProcessExecutorConnect).split(':'); 922 if (Host.empty()) 923 return createTCPSocketError("Host name for -" + 924 OutOfProcessExecutorConnect.ArgStr + 925 " can not be empty"); 926 if (PortStr.empty()) 927 return createTCPSocketError("Port number in -" + 928 OutOfProcessExecutorConnect.ArgStr + 929 " can not be empty"); 930 int Port = 0; 931 if (PortStr.getAsInteger(10, Port)) 932 return createTCPSocketError("Port number '" + PortStr + 933 "' is not a valid integer"); 934 935 Expected<int> SockFD = connectTCPSocket(Host.str(), PortStr.str()); 936 if (!SockFD) 937 return SockFD.takeError(); 938 939 auto S = SimpleRemoteEPC::Setup(); 940 if (UseSharedMemory) 941 S.CreateMemoryManager = createSharedMemoryManager; 942 943 return SimpleRemoteEPC::Create<FDSimpleRemoteEPCTransport>( 944 std::make_unique<DynamicThreadPoolTaskDispatcher>(std::nullopt), 945 std::move(S), *SockFD, *SockFD); 946 #endif 947 } 948 949 class PhonyExternalsGenerator : public DefinitionGenerator { 950 public: 951 Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD, 952 JITDylibLookupFlags JDLookupFlags, 953 const SymbolLookupSet &LookupSet) override { 954 SymbolMap PhonySymbols; 955 for (auto &KV : LookupSet) 956 PhonySymbols[KV.first] = {ExecutorAddr(), JITSymbolFlags::Exported}; 957 return JD.define(absoluteSymbols(std::move(PhonySymbols))); 958 } 959 }; 960 961 Expected<std::unique_ptr<Session::LazyLinkingSupport>> 962 createLazyLinkingSupport(ObjectLinkingLayer &OLL, JITDylib &PlatformJD) { 963 auto RSMgr = JITLinkRedirectableSymbolManager::Create(OLL); 964 if (!RSMgr) 965 return RSMgr.takeError(); 966 967 auto LRMgr = createJITLinkLazyReexportsManager(OLL, **RSMgr, PlatformJD); 968 if (!LRMgr) 969 return LRMgr.takeError(); 970 971 return std::make_unique<Session::LazyLinkingSupport>(std::move(*RSMgr), 972 std::move(*LRMgr), OLL); 973 } 974 975 Expected<std::unique_ptr<Session>> Session::Create(Triple TT, 976 SubtargetFeatures Features) { 977 978 std::unique_ptr<ExecutorProcessControl> EPC; 979 if (OutOfProcessExecutor.getNumOccurrences()) { 980 /// If -oop-executor is passed then launch the executor. 981 if (auto REPC = launchExecutor()) 982 EPC = std::move(*REPC); 983 else 984 return REPC.takeError(); 985 } else if (OutOfProcessExecutorConnect.getNumOccurrences()) { 986 /// If -oop-executor-connect is passed then connect to the executor. 987 if (auto REPC = connectToExecutor()) 988 EPC = std::move(*REPC); 989 else 990 return REPC.takeError(); 991 } else { 992 /// Otherwise use SelfExecutorProcessControl to target the current process. 993 auto PageSize = sys::Process::getPageSize(); 994 if (!PageSize) 995 return PageSize.takeError(); 996 std::unique_ptr<TaskDispatcher> Dispatcher; 997 if (MaterializationThreads == 0) 998 Dispatcher = std::make_unique<InPlaceTaskDispatcher>(); 999 else { 1000 #if LLVM_ENABLE_THREADS 1001 Dispatcher = std::make_unique<DynamicThreadPoolTaskDispatcher>( 1002 MaterializationThreads); 1003 #else 1004 llvm_unreachable("MaterializationThreads should be 0"); 1005 #endif 1006 } 1007 1008 EPC = std::make_unique<SelfExecutorProcessControl>( 1009 std::make_shared<SymbolStringPool>(), std::move(Dispatcher), 1010 std::move(TT), *PageSize, createInProcessMemoryManager()); 1011 } 1012 1013 Error Err = Error::success(); 1014 std::unique_ptr<Session> S(new Session(std::move(EPC), Err)); 1015 if (Err) 1016 return std::move(Err); 1017 S->Features = std::move(Features); 1018 1019 if (lazyLinkingRequested()) { 1020 if (auto LazyLinking = 1021 createLazyLinkingSupport(S->ObjLayer, *S->PlatformJD)) 1022 S->LazyLinking = std::move(*LazyLinking); 1023 else 1024 return LazyLinking.takeError(); 1025 } 1026 1027 return std::move(S); 1028 } 1029 1030 Session::~Session() { 1031 if (auto Err = ES.endSession()) 1032 ES.reportError(std::move(Err)); 1033 } 1034 1035 Session::Session(std::unique_ptr<ExecutorProcessControl> EPC, Error &Err) 1036 : ES(std::move(EPC)), 1037 ObjLayer(ES, ES.getExecutorProcessControl().getMemMgr()) { 1038 1039 /// Local ObjectLinkingLayer::Plugin class to forward modifyPassConfig to the 1040 /// Session. 1041 class JITLinkSessionPlugin : public ObjectLinkingLayer::Plugin { 1042 public: 1043 JITLinkSessionPlugin(Session &S) : S(S) {} 1044 void modifyPassConfig(MaterializationResponsibility &MR, LinkGraph &G, 1045 PassConfiguration &PassConfig) override { 1046 S.modifyPassConfig(G, PassConfig); 1047 } 1048 1049 Error notifyFailed(MaterializationResponsibility &MR) override { 1050 return Error::success(); 1051 } 1052 Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override { 1053 return Error::success(); 1054 } 1055 void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey, 1056 ResourceKey SrcKey) override {} 1057 1058 private: 1059 Session &S; 1060 }; 1061 1062 ErrorAsOutParameter _(&Err); 1063 1064 ES.setErrorReporter(reportLLVMJITLinkError); 1065 1066 if (!NoProcessSymbols) 1067 ExitOnErr(loadProcessSymbols(*this)); 1068 1069 ExitOnErr(loadDylibs(*this)); 1070 1071 auto &TT = ES.getTargetTriple(); 1072 1073 if (DebuggerSupport && TT.isOSBinFormatMachO()) { 1074 if (!ProcessSymsJD) { 1075 Err = make_error<StringError>("MachO debugging requires process symbols", 1076 inconvertibleErrorCode()); 1077 return; 1078 } 1079 ObjLayer.addPlugin(ExitOnErr(GDBJITDebugInfoRegistrationPlugin::Create( 1080 this->ES, *ProcessSymsJD, TT))); 1081 } 1082 1083 if (PerfSupport && TT.isOSBinFormatELF()) { 1084 if (!ProcessSymsJD) { 1085 Err = make_error<StringError>("MachO debugging requires process symbols", 1086 inconvertibleErrorCode()); 1087 return; 1088 } 1089 ObjLayer.addPlugin(ExitOnErr(DebugInfoPreservationPlugin::Create())); 1090 ObjLayer.addPlugin(ExitOnErr(PerfSupportPlugin::Create( 1091 this->ES.getExecutorProcessControl(), *ProcessSymsJD, true, true))); 1092 } 1093 1094 if (VTuneSupport && TT.isOSBinFormatELF()) { 1095 ObjLayer.addPlugin(ExitOnErr(DebugInfoPreservationPlugin::Create())); 1096 ObjLayer.addPlugin(ExitOnErr( 1097 VTuneSupportPlugin::Create(this->ES.getExecutorProcessControl(), 1098 *ProcessSymsJD, /*EmitDebugInfo=*/true, 1099 /*TestMode=*/true))); 1100 } 1101 1102 // Set up the platform. 1103 if (!OrcRuntime.empty()) { 1104 assert(ProcessSymsJD && "ProcessSymsJD should have been set"); 1105 PlatformJD = &ES.createBareJITDylib("Platform"); 1106 PlatformJD->addToLinkOrder(*ProcessSymsJD); 1107 1108 if (TT.isOSBinFormatMachO()) { 1109 if (auto P = 1110 MachOPlatform::Create(ObjLayer, *PlatformJD, OrcRuntime.c_str())) 1111 ES.setPlatform(std::move(*P)); 1112 else { 1113 Err = P.takeError(); 1114 return; 1115 } 1116 } else if (TT.isOSBinFormatELF()) { 1117 if (auto P = 1118 ELFNixPlatform::Create(ObjLayer, *PlatformJD, OrcRuntime.c_str())) 1119 ES.setPlatform(std::move(*P)); 1120 else { 1121 Err = P.takeError(); 1122 return; 1123 } 1124 } else if (TT.isOSBinFormatCOFF()) { 1125 auto LoadDynLibrary = [&, this](JITDylib &JD, 1126 StringRef DLLName) -> Error { 1127 if (!DLLName.ends_with_insensitive(".dll")) 1128 return make_error<StringError>("DLLName not ending with .dll", 1129 inconvertibleErrorCode()); 1130 return loadAndLinkDynamicLibrary(JD, DLLName); 1131 }; 1132 1133 if (auto P = 1134 COFFPlatform::Create(ObjLayer, *PlatformJD, OrcRuntime.c_str(), 1135 std::move(LoadDynLibrary))) 1136 ES.setPlatform(std::move(*P)); 1137 else { 1138 Err = P.takeError(); 1139 return; 1140 } 1141 } else { 1142 Err = make_error<StringError>( 1143 "-" + OrcRuntime.ArgStr + " specified, but format " + 1144 Triple::getObjectFormatTypeName(TT.getObjectFormat()) + 1145 " not supported", 1146 inconvertibleErrorCode()); 1147 return; 1148 } 1149 } else if (TT.isOSBinFormatELF()) { 1150 if (!NoExec) 1151 ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>( 1152 ES, ExitOnErr(EPCEHFrameRegistrar::Create(this->ES)))); 1153 if (DebuggerSupport) 1154 ObjLayer.addPlugin(std::make_unique<DebugObjectManagerPlugin>( 1155 ES, ExitOnErr(createJITLoaderGDBRegistrar(this->ES)), true, true)); 1156 } 1157 1158 if (auto MainJDOrErr = ES.createJITDylib("main")) 1159 MainJD = &*MainJDOrErr; 1160 else { 1161 Err = MainJDOrErr.takeError(); 1162 return; 1163 } 1164 1165 if (NoProcessSymbols) { 1166 // This symbol is used in testcases, but we're not reflecting process 1167 // symbols so we'll need to make it available some other way. 1168 auto &TestResultJD = ES.createBareJITDylib("<TestResultJD>"); 1169 ExitOnErr(TestResultJD.define(absoluteSymbols( 1170 {{ES.intern("llvm_jitlink_setTestResultOverride"), 1171 {ExecutorAddr::fromPtr(llvm_jitlink_setTestResultOverride), 1172 JITSymbolFlags::Exported}}}))); 1173 MainJD->addToLinkOrder(TestResultJD); 1174 } 1175 1176 ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this)); 1177 1178 // Process any harness files. 1179 for (auto &HarnessFile : TestHarnesses) { 1180 HarnessFiles.insert(HarnessFile); 1181 1182 auto ObjBuffer = 1183 ExitOnErr(loadLinkableFile(HarnessFile, ES.getTargetTriple(), 1184 LoadArchives::Never)) 1185 .first; 1186 1187 auto ObjInterface = 1188 ExitOnErr(getObjectFileInterface(ES, ObjBuffer->getMemBufferRef())); 1189 1190 for (auto &KV : ObjInterface.SymbolFlags) 1191 HarnessDefinitions.insert(*KV.first); 1192 1193 auto Obj = ExitOnErr( 1194 object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef())); 1195 1196 for (auto &Sym : Obj->symbols()) { 1197 uint32_t SymFlags = ExitOnErr(Sym.getFlags()); 1198 auto Name = ExitOnErr(Sym.getName()); 1199 1200 if (Name.empty()) 1201 continue; 1202 1203 if (SymFlags & object::BasicSymbolRef::SF_Undefined) 1204 HarnessExternals.insert(Name); 1205 } 1206 } 1207 1208 // If a name is defined by some harness file then it's a definition, not an 1209 // external. 1210 for (auto &DefName : HarnessDefinitions) 1211 HarnessExternals.erase(DefName.getKey()); 1212 1213 if (!ShowLinkGraphs.empty()) 1214 ShowGraphsRegex = Regex(ShowLinkGraphs); 1215 } 1216 1217 void Session::dumpSessionInfo(raw_ostream &OS) { 1218 OS << "Registered addresses:\n" << SymbolInfos << FileInfos; 1219 } 1220 1221 void Session::modifyPassConfig(LinkGraph &G, PassConfiguration &PassConfig) { 1222 1223 if (ShowLinkedFiles) 1224 outs() << "Linking " << G.getName() << "\n"; 1225 1226 if (!CheckFiles.empty()) 1227 PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) { 1228 if (ES.getTargetTriple().getObjectFormat() == Triple::ELF) 1229 return registerELFGraphInfo(*this, G); 1230 1231 if (ES.getTargetTriple().getObjectFormat() == Triple::MachO) 1232 return registerMachOGraphInfo(*this, G); 1233 1234 if (ES.getTargetTriple().getObjectFormat() == Triple::COFF) 1235 return registerCOFFGraphInfo(*this, G); 1236 1237 return make_error<StringError>("Unsupported object format for GOT/stub " 1238 "registration", 1239 inconvertibleErrorCode()); 1240 }); 1241 1242 if (ShowGraphsRegex) 1243 PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error { 1244 std::lock_guard<std::mutex> Lock(M); 1245 // Print graph if ShowLinkGraphs is specified-but-empty, or if 1246 // it contains the given graph. 1247 if (ShowGraphsRegex->match(G.getName())) { 1248 outs() << "Link graph \"" << G.getName() << "\" post-fixup:\n"; 1249 G.dump(outs()); 1250 } 1251 return Error::success(); 1252 }); 1253 1254 PassConfig.PrePrunePasses.push_back([this](LinkGraph &G) { 1255 std::lock_guard<std::mutex> Lock(M); 1256 ++ActiveLinks; 1257 return Error::success(); 1258 }); 1259 PassConfig.PrePrunePasses.push_back( 1260 [this](LinkGraph &G) { return applyHarnessPromotions(*this, G); }); 1261 1262 if (ShowRelocatedSectionContents) 1263 PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error { 1264 dumpSectionContents(outs(), *this, G); 1265 return Error::success(); 1266 }); 1267 1268 if (AddSelfRelocations) 1269 PassConfig.PostPrunePasses.push_back(addSelfRelocations); 1270 1271 PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) { 1272 std::lock_guard<std::mutex> Lock(M); 1273 if (--ActiveLinks == 0) 1274 ActiveLinksCV.notify_all(); 1275 return Error::success(); 1276 }); 1277 } 1278 1279 Expected<JITDylib *> Session::getOrLoadDynamicLibrary(StringRef LibPath) { 1280 auto It = DynLibJDs.find(LibPath); 1281 if (It != DynLibJDs.end()) { 1282 return It->second; 1283 } 1284 auto G = EPCDynamicLibrarySearchGenerator::Load(ES, LibPath.data()); 1285 if (!G) 1286 return G.takeError(); 1287 auto JD = &ES.createBareJITDylib(LibPath.str()); 1288 1289 JD->addGenerator(std::move(*G)); 1290 DynLibJDs.emplace(LibPath.str(), JD); 1291 LLVM_DEBUG({ 1292 dbgs() << "Loaded dynamic library " << LibPath.data() << " for " << LibPath 1293 << "\n"; 1294 }); 1295 return JD; 1296 } 1297 1298 Error Session::loadAndLinkDynamicLibrary(JITDylib &JD, StringRef LibPath) { 1299 auto DL = getOrLoadDynamicLibrary(LibPath); 1300 if (!DL) 1301 return DL.takeError(); 1302 JD.addToLinkOrder(**DL); 1303 LLVM_DEBUG({ 1304 dbgs() << "Linking dynamic library " << LibPath << " to " << JD.getName() 1305 << "\n"; 1306 }); 1307 return Error::success(); 1308 } 1309 1310 Error Session::FileInfo::registerGOTEntry( 1311 LinkGraph &G, Symbol &Sym, GetSymbolTargetFunction GetSymbolTarget) { 1312 if (Sym.isSymbolZeroFill()) 1313 return make_error<StringError>("Unexpected zero-fill symbol in section " + 1314 Sym.getBlock().getSection().getName(), 1315 inconvertibleErrorCode()); 1316 auto TS = GetSymbolTarget(G, Sym.getBlock()); 1317 if (!TS) 1318 return TS.takeError(); 1319 GOTEntryInfos[*TS->getName()] = {Sym.getSymbolContent(), 1320 Sym.getAddress().getValue(), 1321 Sym.getTargetFlags()}; 1322 return Error::success(); 1323 } 1324 1325 Error Session::FileInfo::registerStubEntry( 1326 LinkGraph &G, Symbol &Sym, GetSymbolTargetFunction GetSymbolTarget) { 1327 if (Sym.isSymbolZeroFill()) 1328 return make_error<StringError>("Unexpected zero-fill symbol in section " + 1329 Sym.getBlock().getSection().getName(), 1330 inconvertibleErrorCode()); 1331 auto TS = GetSymbolTarget(G, Sym.getBlock()); 1332 if (!TS) 1333 return TS.takeError(); 1334 1335 SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[*TS->getName()]; 1336 Entry.insert(Entry.begin(), 1337 {Sym.getSymbolContent(), Sym.getAddress().getValue(), 1338 Sym.getTargetFlags()}); 1339 return Error::success(); 1340 } 1341 1342 Error Session::FileInfo::registerMultiStubEntry( 1343 LinkGraph &G, Symbol &Sym, GetSymbolTargetFunction GetSymbolTarget) { 1344 if (Sym.isSymbolZeroFill()) 1345 return make_error<StringError>("Unexpected zero-fill symbol in section " + 1346 Sym.getBlock().getSection().getName(), 1347 inconvertibleErrorCode()); 1348 1349 auto Target = GetSymbolTarget(G, Sym.getBlock()); 1350 if (!Target) 1351 return Target.takeError(); 1352 1353 SmallVectorImpl<MemoryRegionInfo> &Entry = StubInfos[*Target->getName()]; 1354 Entry.emplace_back(Sym.getSymbolContent(), Sym.getAddress().getValue(), 1355 Sym.getTargetFlags()); 1356 1357 // Let's keep stubs ordered by ascending address. 1358 std::sort(Entry.begin(), Entry.end(), 1359 [](const MemoryRegionInfo &L, const MemoryRegionInfo &R) { 1360 return L.getTargetAddress() < R.getTargetAddress(); 1361 }); 1362 1363 return Error::success(); 1364 } 1365 1366 Expected<Session::FileInfo &> Session::findFileInfo(StringRef FileName) { 1367 auto FileInfoItr = FileInfos.find(FileName); 1368 if (FileInfoItr == FileInfos.end()) 1369 return make_error<StringError>("file \"" + FileName + "\" not recognized", 1370 inconvertibleErrorCode()); 1371 return FileInfoItr->second; 1372 } 1373 1374 Expected<Session::MemoryRegionInfo &> 1375 Session::findSectionInfo(StringRef FileName, StringRef SectionName) { 1376 auto FI = findFileInfo(FileName); 1377 if (!FI) 1378 return FI.takeError(); 1379 auto SecInfoItr = FI->SectionInfos.find(SectionName); 1380 if (SecInfoItr == FI->SectionInfos.end()) 1381 return make_error<StringError>("no section \"" + SectionName + 1382 "\" registered for file \"" + FileName + 1383 "\"", 1384 inconvertibleErrorCode()); 1385 return SecInfoItr->second; 1386 } 1387 1388 class MemoryMatcher { 1389 public: 1390 MemoryMatcher(ArrayRef<char> Content) 1391 : Pos(Content.data()), End(Pos + Content.size()) {} 1392 1393 template <typename MaskType> bool matchMask(MaskType Mask) { 1394 if (Mask == (Mask & *reinterpret_cast<const MaskType *>(Pos))) { 1395 Pos += sizeof(MaskType); 1396 return true; 1397 } 1398 return false; 1399 } 1400 1401 template <typename ValueType> bool matchEqual(ValueType Value) { 1402 if (Value == *reinterpret_cast<const ValueType *>(Pos)) { 1403 Pos += sizeof(ValueType); 1404 return true; 1405 } 1406 return false; 1407 } 1408 1409 bool done() const { return Pos == End; } 1410 1411 private: 1412 const char *Pos; 1413 const char *End; 1414 }; 1415 1416 static StringRef detectStubKind(const Session::MemoryRegionInfo &Stub) { 1417 using namespace support::endian; 1418 auto Armv7MovWTle = byte_swap<uint32_t, endianness::little>(0xe300c000); 1419 auto Armv7BxR12le = byte_swap<uint32_t, endianness::little>(0xe12fff1c); 1420 auto Thumbv7MovWTle = byte_swap<uint32_t, endianness::little>(0x0c00f240); 1421 auto Thumbv7BxR12le = byte_swap<uint16_t, endianness::little>(0x4760); 1422 1423 MemoryMatcher M(Stub.getContent()); 1424 if (M.matchMask(Thumbv7MovWTle)) { 1425 if (M.matchMask(Thumbv7MovWTle)) 1426 if (M.matchEqual(Thumbv7BxR12le)) 1427 if (M.done()) 1428 return "thumbv7_abs_le"; 1429 } else if (M.matchMask(Armv7MovWTle)) { 1430 if (M.matchMask(Armv7MovWTle)) 1431 if (M.matchEqual(Armv7BxR12le)) 1432 if (M.done()) 1433 return "armv7_abs_le"; 1434 } 1435 return ""; 1436 } 1437 1438 Expected<Session::MemoryRegionInfo &> 1439 Session::findStubInfo(StringRef FileName, StringRef TargetName, 1440 StringRef KindNameFilter) { 1441 auto FI = findFileInfo(FileName); 1442 if (!FI) 1443 return FI.takeError(); 1444 auto StubInfoItr = FI->StubInfos.find(TargetName); 1445 if (StubInfoItr == FI->StubInfos.end()) 1446 return make_error<StringError>("no stub for \"" + TargetName + 1447 "\" registered for file \"" + FileName + 1448 "\"", 1449 inconvertibleErrorCode()); 1450 auto &StubsForTarget = StubInfoItr->second; 1451 assert(!StubsForTarget.empty() && "At least 1 stub in each entry"); 1452 if (KindNameFilter.empty() && StubsForTarget.size() == 1) 1453 return StubsForTarget[0]; // Regular single-stub match 1454 1455 std::string KindsStr; 1456 SmallVector<MemoryRegionInfo *, 1> Matches; 1457 Regex KindNameMatcher(KindNameFilter.empty() ? ".*" : KindNameFilter); 1458 for (MemoryRegionInfo &Stub : StubsForTarget) { 1459 StringRef Kind = detectStubKind(Stub); 1460 if (KindNameMatcher.match(Kind)) 1461 Matches.push_back(&Stub); 1462 KindsStr += "\"" + (Kind.empty() ? "<unknown>" : Kind.str()) + "\", "; 1463 } 1464 if (Matches.empty()) 1465 return make_error<StringError>( 1466 "\"" + TargetName + "\" has " + Twine(StubsForTarget.size()) + 1467 " stubs in file \"" + FileName + 1468 "\", but none of them matches the stub-kind filter \"" + 1469 KindNameFilter + "\" (all encountered kinds are " + 1470 StringRef(KindsStr.data(), KindsStr.size() - 2) + ").", 1471 inconvertibleErrorCode()); 1472 if (Matches.size() > 1) 1473 return make_error<StringError>( 1474 "\"" + TargetName + "\" has " + Twine(Matches.size()) + 1475 " candidate stubs in file \"" + FileName + 1476 "\". Please refine stub-kind filter \"" + KindNameFilter + 1477 "\" for disambiguation (encountered kinds are " + 1478 StringRef(KindsStr.data(), KindsStr.size() - 2) + ").", 1479 inconvertibleErrorCode()); 1480 1481 return *Matches[0]; 1482 } 1483 1484 Expected<Session::MemoryRegionInfo &> 1485 Session::findGOTEntryInfo(StringRef FileName, StringRef TargetName) { 1486 auto FI = findFileInfo(FileName); 1487 if (!FI) 1488 return FI.takeError(); 1489 auto GOTInfoItr = FI->GOTEntryInfos.find(TargetName); 1490 if (GOTInfoItr == FI->GOTEntryInfos.end()) 1491 return make_error<StringError>("no GOT entry for \"" + TargetName + 1492 "\" registered for file \"" + FileName + 1493 "\"", 1494 inconvertibleErrorCode()); 1495 return GOTInfoItr->second; 1496 } 1497 1498 bool Session::isSymbolRegistered(const orc::SymbolStringPtr &SymbolName) { 1499 return SymbolInfos.count(SymbolName); 1500 } 1501 1502 Expected<Session::MemoryRegionInfo &> 1503 Session::findSymbolInfo(const orc::SymbolStringPtr &SymbolName, 1504 Twine ErrorMsgStem) { 1505 auto SymInfoItr = SymbolInfos.find(SymbolName); 1506 if (SymInfoItr == SymbolInfos.end()) 1507 return make_error<StringError>(ErrorMsgStem + ": symbol " + *SymbolName + 1508 " not found", 1509 inconvertibleErrorCode()); 1510 return SymInfoItr->second; 1511 } 1512 1513 } // end namespace llvm 1514 1515 static std::pair<Triple, SubtargetFeatures> getFirstFileTripleAndFeatures() { 1516 static std::pair<Triple, SubtargetFeatures> FirstTTAndFeatures = []() { 1517 assert(!InputFiles.empty() && "InputFiles can not be empty"); 1518 1519 if (!OverrideTriple.empty()) { 1520 LLVM_DEBUG({ 1521 dbgs() << "Triple from -triple override: " << OverrideTriple << "\n"; 1522 }); 1523 return std::make_pair(Triple(OverrideTriple), SubtargetFeatures()); 1524 } 1525 1526 for (auto InputFile : InputFiles) { 1527 auto ObjBuffer = ExitOnErr(getFile(InputFile)); 1528 file_magic Magic = identify_magic(ObjBuffer->getBuffer()); 1529 switch (Magic) { 1530 case file_magic::coff_object: 1531 case file_magic::elf_relocatable: 1532 case file_magic::macho_object: { 1533 auto Obj = ExitOnErr( 1534 object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef())); 1535 Triple TT = Obj->makeTriple(); 1536 if (Magic == file_magic::coff_object) { 1537 // TODO: Move this to makeTriple() if possible. 1538 TT.setObjectFormat(Triple::COFF); 1539 TT.setOS(Triple::OSType::Win32); 1540 } 1541 SubtargetFeatures Features; 1542 if (auto ObjFeatures = Obj->getFeatures()) 1543 Features = std::move(*ObjFeatures); 1544 1545 LLVM_DEBUG({ 1546 dbgs() << "Triple from " << InputFile << ": " << TT.str() << "\n"; 1547 }); 1548 return std::make_pair(TT, Features); 1549 } 1550 default: 1551 break; 1552 } 1553 } 1554 1555 // If no plain object file inputs exist to pin down the triple then detect 1556 // the host triple and default to that. 1557 auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost()); 1558 LLVM_DEBUG({ 1559 dbgs() << "Triple from host-detection: " << JTMB.getTargetTriple().str() 1560 << "\n"; 1561 }); 1562 return std::make_pair(JTMB.getTargetTriple(), JTMB.getFeatures()); 1563 }(); 1564 1565 return FirstTTAndFeatures; 1566 } 1567 1568 static Error sanitizeArguments(const Triple &TT, const char *ArgV0) { 1569 1570 // -noexec and --args should not be used together. 1571 if (NoExec && !InputArgv.empty()) 1572 errs() << "Warning: --args passed to -noexec run will be ignored.\n"; 1573 1574 // Set the entry point name if not specified. 1575 if (EntryPointName.empty()) 1576 EntryPointName = TT.getObjectFormat() == Triple::MachO ? "_main" : "main"; 1577 1578 // Disable debugger support by default in noexec tests. 1579 if (DebuggerSupport.getNumOccurrences() == 0 && NoExec) 1580 DebuggerSupport = false; 1581 1582 if (!OrcRuntime.empty() && NoProcessSymbols) 1583 return make_error<StringError>("-orc-runtime requires process symbols", 1584 inconvertibleErrorCode()); 1585 1586 // If -slab-allocate is passed, check that we're not trying to use it in 1587 // -oop-executor or -oop-executor-connect mode. 1588 // 1589 // FIXME: Remove once we enable remote slab allocation. 1590 if (SlabAllocateSizeString != "") { 1591 if (OutOfProcessExecutor.getNumOccurrences() || 1592 OutOfProcessExecutorConnect.getNumOccurrences()) 1593 return make_error<StringError>( 1594 "-slab-allocate cannot be used with -oop-executor or " 1595 "-oop-executor-connect", 1596 inconvertibleErrorCode()); 1597 } 1598 1599 // If -slab-address is passed, require -slab-allocate and -noexec 1600 if (SlabAddress != ~0ULL) { 1601 if (SlabAllocateSizeString == "" || !NoExec) 1602 return make_error<StringError>( 1603 "-slab-address requires -slab-allocate and -noexec", 1604 inconvertibleErrorCode()); 1605 1606 if (SlabPageSize == 0) 1607 errs() << "Warning: -slab-address used without -slab-page-size.\n"; 1608 } 1609 1610 if (SlabPageSize != 0) { 1611 // -slab-page-size requires slab alloc. 1612 if (SlabAllocateSizeString == "") 1613 return make_error<StringError>("-slab-page-size requires -slab-allocate", 1614 inconvertibleErrorCode()); 1615 1616 // Check -slab-page-size / -noexec interactions. 1617 if (!NoExec) { 1618 if (auto RealPageSize = sys::Process::getPageSize()) { 1619 if (SlabPageSize % *RealPageSize) 1620 return make_error<StringError>( 1621 "-slab-page-size must be a multiple of real page size for exec " 1622 "tests (did you mean to use -noexec ?)\n", 1623 inconvertibleErrorCode()); 1624 } else { 1625 errs() << "Could not retrieve process page size:\n"; 1626 logAllUnhandledErrors(RealPageSize.takeError(), errs(), ""); 1627 errs() << "Executing with slab page size = " 1628 << formatv("{0:x}", SlabPageSize) << ".\n" 1629 << "Tool may crash if " << formatv("{0:x}", SlabPageSize) 1630 << " is not a multiple of the real process page size.\n" 1631 << "(did you mean to use -noexec ?)"; 1632 } 1633 } 1634 } 1635 1636 #if LLVM_ENABLE_THREADS 1637 if (MaterializationThreads == std::numeric_limits<size_t>::max()) { 1638 if (auto HC = std::thread::hardware_concurrency()) 1639 MaterializationThreads = HC; 1640 else { 1641 errs() << "Warning: std::thread::hardware_concurrency() returned 0, " 1642 "defaulting to -num-threads=1.\n"; 1643 MaterializationThreads = 1; 1644 } 1645 } 1646 #else 1647 if (MaterializationThreads.getNumOccurrences() && 1648 MaterializationThreads != 0) { 1649 errs() << "Warning: -num-threads was set, but LLVM was built with threads " 1650 "disabled. Resetting to -num-threads=0\n"; 1651 } 1652 MaterializationThreads = 0; 1653 #endif 1654 1655 if (!!OutOfProcessExecutor.getNumOccurrences() || 1656 !!OutOfProcessExecutorConnect.getNumOccurrences()) { 1657 if (NoExec) 1658 return make_error<StringError>("-noexec cannot be used with " + 1659 OutOfProcessExecutor.ArgStr + " or " + 1660 OutOfProcessExecutorConnect.ArgStr, 1661 inconvertibleErrorCode()); 1662 1663 if (MaterializationThreads == 0) 1664 return make_error<StringError>("-threads=0 cannot be used with " + 1665 OutOfProcessExecutor.ArgStr + " or " + 1666 OutOfProcessExecutorConnect.ArgStr, 1667 inconvertibleErrorCode()); 1668 } 1669 1670 #ifndef NDEBUG 1671 if (DebugFlag && MaterializationThreads != 0) 1672 errs() << "Warning: debugging output is not thread safe. " 1673 "Use -num-threads=0 to stabilize output.\n"; 1674 #endif // NDEBUG 1675 1676 // Only one of -oop-executor and -oop-executor-connect can be used. 1677 if (!!OutOfProcessExecutor.getNumOccurrences() && 1678 !!OutOfProcessExecutorConnect.getNumOccurrences()) 1679 return make_error<StringError>( 1680 "Only one of -" + OutOfProcessExecutor.ArgStr + " and -" + 1681 OutOfProcessExecutorConnect.ArgStr + " can be specified", 1682 inconvertibleErrorCode()); 1683 1684 // If -oop-executor was used but no value was specified then use a sensible 1685 // default. 1686 if (!!OutOfProcessExecutor.getNumOccurrences() && 1687 OutOfProcessExecutor.empty()) { 1688 SmallString<256> OOPExecutorPath(sys::fs::getMainExecutable( 1689 ArgV0, reinterpret_cast<void *>(&sanitizeArguments))); 1690 sys::path::remove_filename(OOPExecutorPath); 1691 sys::path::append(OOPExecutorPath, "llvm-jitlink-executor"); 1692 OutOfProcessExecutor = OOPExecutorPath.str().str(); 1693 } 1694 1695 // If lazy linking is requested then check compatibility with other options. 1696 if (lazyLinkingRequested()) { 1697 if (OrcRuntime.empty()) 1698 return make_error<StringError>("Lazy linking requries the ORC runtime", 1699 inconvertibleErrorCode()); 1700 1701 if (!TestHarnesses.empty()) 1702 return make_error<StringError>( 1703 "Lazy linking cannot be used with -harness mode", 1704 inconvertibleErrorCode()); 1705 } 1706 1707 return Error::success(); 1708 } 1709 1710 static void addPhonyExternalsGenerator(Session &S) { 1711 S.MainJD->addGenerator(std::make_unique<PhonyExternalsGenerator>()); 1712 } 1713 1714 static Error createJITDylibs(Session &S, 1715 std::map<unsigned, JITDylib *> &IdxToJD) { 1716 // First, set up JITDylibs. 1717 LLVM_DEBUG(dbgs() << "Creating JITDylibs...\n"); 1718 { 1719 // Create a "main" JITLinkDylib. 1720 IdxToJD[0] = S.MainJD; 1721 S.JDSearchOrder.push_back({S.MainJD, JITDylibLookupFlags::MatchAllSymbols}); 1722 LLVM_DEBUG(dbgs() << " 0: " << S.MainJD->getName() << "\n"); 1723 1724 // Add any extra JITDylibs from the command line. 1725 for (auto JDItr = JITDylibs.begin(), JDEnd = JITDylibs.end(); 1726 JDItr != JDEnd; ++JDItr) { 1727 auto JD = S.ES.createJITDylib(*JDItr); 1728 if (!JD) 1729 return JD.takeError(); 1730 unsigned JDIdx = JITDylibs.getPosition(JDItr - JITDylibs.begin()); 1731 IdxToJD[JDIdx] = &*JD; 1732 S.JDSearchOrder.push_back({&*JD, JITDylibLookupFlags::MatchAllSymbols}); 1733 LLVM_DEBUG(dbgs() << " " << JDIdx << ": " << JD->getName() << "\n"); 1734 } 1735 } 1736 1737 if (S.PlatformJD) 1738 S.JDSearchOrder.push_back( 1739 {S.PlatformJD, JITDylibLookupFlags::MatchExportedSymbolsOnly}); 1740 if (S.ProcessSymsJD) 1741 S.JDSearchOrder.push_back( 1742 {S.ProcessSymsJD, JITDylibLookupFlags::MatchExportedSymbolsOnly}); 1743 1744 LLVM_DEBUG({ 1745 dbgs() << "Dylib search order is [ "; 1746 for (auto &KV : S.JDSearchOrder) 1747 dbgs() << KV.first->getName() << " "; 1748 dbgs() << "]\n"; 1749 }); 1750 1751 return Error::success(); 1752 } 1753 1754 static Error addAbsoluteSymbols(Session &S, 1755 const std::map<unsigned, JITDylib *> &IdxToJD) { 1756 // Define absolute symbols. 1757 LLVM_DEBUG(dbgs() << "Defining absolute symbols...\n"); 1758 for (auto AbsDefItr = AbsoluteDefs.begin(), AbsDefEnd = AbsoluteDefs.end(); 1759 AbsDefItr != AbsDefEnd; ++AbsDefItr) { 1760 unsigned AbsDefArgIdx = 1761 AbsoluteDefs.getPosition(AbsDefItr - AbsoluteDefs.begin()); 1762 auto &JD = *std::prev(IdxToJD.lower_bound(AbsDefArgIdx))->second; 1763 1764 StringRef AbsDefStmt = *AbsDefItr; 1765 size_t EqIdx = AbsDefStmt.find_first_of('='); 1766 if (EqIdx == StringRef::npos) 1767 return make_error<StringError>("Invalid absolute define \"" + AbsDefStmt + 1768 "\". Syntax: <name>=<addr>", 1769 inconvertibleErrorCode()); 1770 StringRef Name = AbsDefStmt.substr(0, EqIdx).trim(); 1771 StringRef AddrStr = AbsDefStmt.substr(EqIdx + 1).trim(); 1772 1773 uint64_t Addr; 1774 if (AddrStr.getAsInteger(0, Addr)) 1775 return make_error<StringError>("Invalid address expression \"" + AddrStr + 1776 "\" in absolute symbol definition \"" + 1777 AbsDefStmt + "\"", 1778 inconvertibleErrorCode()); 1779 ExecutorSymbolDef AbsDef(ExecutorAddr(Addr), JITSymbolFlags::Exported); 1780 auto InternedName = S.ES.intern(Name); 1781 if (auto Err = JD.define(absoluteSymbols({{InternedName, AbsDef}}))) 1782 return Err; 1783 1784 // Register the absolute symbol with the session symbol infos. 1785 S.SymbolInfos[std::move(InternedName)] = 1786 {ArrayRef<char>(), Addr, AbsDef.getFlags().getTargetFlags()}; 1787 } 1788 1789 return Error::success(); 1790 } 1791 1792 static Error addAliases(Session &S, 1793 const std::map<unsigned, JITDylib *> &IdxToJD) { 1794 // Define absolute symbols. 1795 LLVM_DEBUG(dbgs() << "Defining aliases...\n"); 1796 1797 DenseMap<std::pair<JITDylib *, JITDylib *>, SymbolAliasMap> Reexports; 1798 for (auto AliasItr = Aliases.begin(), AliasEnd = Aliases.end(); 1799 AliasItr != AliasEnd; ++AliasItr) { 1800 1801 auto BadExpr = [&]() { 1802 return make_error<StringError>( 1803 "Invalid alias definition \"" + *AliasItr + 1804 "\". Syntax: [<dst-jd>:]<alias>=[<src-jd>:]<aliasee>", 1805 inconvertibleErrorCode()); 1806 }; 1807 1808 auto GetJD = [&](StringRef JDName) -> Expected<JITDylib *> { 1809 if (JDName.empty()) { 1810 unsigned AliasArgIdx = Aliases.getPosition(AliasItr - Aliases.begin()); 1811 return std::prev(IdxToJD.lower_bound(AliasArgIdx))->second; 1812 } 1813 1814 auto *JD = S.ES.getJITDylibByName(JDName); 1815 if (!JD) 1816 return make_error<StringError>(StringRef("In alias definition \"") + 1817 *AliasItr + "\" no dylib named " + 1818 JDName, 1819 inconvertibleErrorCode()); 1820 1821 return JD; 1822 }; 1823 1824 { 1825 // First split on '=' to get alias and aliasee. 1826 StringRef AliasStmt = *AliasItr; 1827 auto [AliasExpr, AliaseeExpr] = AliasStmt.split('='); 1828 if (AliaseeExpr.empty()) 1829 return BadExpr(); 1830 1831 auto [AliasJDName, Alias] = AliasExpr.split(':'); 1832 if (Alias.empty()) 1833 std::swap(AliasJDName, Alias); 1834 1835 auto AliasJD = GetJD(AliasJDName); 1836 if (!AliasJD) 1837 return AliasJD.takeError(); 1838 1839 auto [AliaseeJDName, Aliasee] = AliaseeExpr.split(':'); 1840 if (Aliasee.empty()) 1841 std::swap(AliaseeJDName, Aliasee); 1842 1843 if (AliaseeJDName.empty() && !AliasJDName.empty()) 1844 AliaseeJDName = AliasJDName; 1845 auto AliaseeJD = GetJD(AliaseeJDName); 1846 if (!AliaseeJD) 1847 return AliaseeJD.takeError(); 1848 1849 Reexports[{*AliasJD, *AliaseeJD}][S.ES.intern(Alias)] = { 1850 S.ES.intern(Aliasee), JITSymbolFlags::Exported}; 1851 } 1852 } 1853 1854 for (auto &[JDs, AliasMap] : Reexports) { 1855 auto [DstJD, SrcJD] = JDs; 1856 if (auto Err = DstJD->define(reexports(*SrcJD, std::move(AliasMap)))) 1857 return Err; 1858 } 1859 1860 return Error::success(); 1861 } 1862 1863 static Error addSectCreates(Session &S, 1864 const std::map<unsigned, JITDylib *> &IdxToJD) { 1865 for (auto SCItr = SectCreate.begin(), SCEnd = SectCreate.end(); 1866 SCItr != SCEnd; ++SCItr) { 1867 1868 unsigned SCArgIdx = SectCreate.getPosition(SCItr - SectCreate.begin()); 1869 auto &JD = *std::prev(IdxToJD.lower_bound(SCArgIdx))->second; 1870 1871 StringRef SCArg(*SCItr); 1872 1873 auto [SectAndFileName, ExtraSymbolsString] = SCArg.rsplit('@'); 1874 auto [SectName, FileName] = SectAndFileName.rsplit(','); 1875 if (SectName.empty()) 1876 return make_error<StringError>("In -sectcreate=" + SCArg + 1877 ", filename component cannot be empty", 1878 inconvertibleErrorCode()); 1879 if (FileName.empty()) 1880 return make_error<StringError>("In -sectcreate=" + SCArg + 1881 ", filename component cannot be empty", 1882 inconvertibleErrorCode()); 1883 1884 auto Content = getFile(FileName); 1885 if (!Content) 1886 return Content.takeError(); 1887 1888 SectCreateMaterializationUnit::ExtraSymbolsMap ExtraSymbols; 1889 while (!ExtraSymbolsString.empty()) { 1890 StringRef NextSymPair; 1891 std::tie(NextSymPair, ExtraSymbolsString) = ExtraSymbolsString.split(','); 1892 1893 auto [Sym, OffsetString] = NextSymPair.split('='); 1894 size_t Offset; 1895 1896 if (OffsetString.getAsInteger(0, Offset)) 1897 return make_error<StringError>("In -sectcreate=" + SCArg + ", " + 1898 OffsetString + 1899 " is not a valid integer", 1900 inconvertibleErrorCode()); 1901 1902 ExtraSymbols[S.ES.intern(Sym)] = {JITSymbolFlags::Exported, Offset}; 1903 } 1904 1905 if (auto Err = JD.define(std::make_unique<SectCreateMaterializationUnit>( 1906 S.ObjLayer, SectName.str(), MemProt::Read, 16, std::move(*Content), 1907 std::move(ExtraSymbols)))) 1908 return Err; 1909 } 1910 1911 return Error::success(); 1912 } 1913 1914 static Error addTestHarnesses(Session &S) { 1915 LLVM_DEBUG(dbgs() << "Adding test harness objects...\n"); 1916 for (auto HarnessFile : TestHarnesses) { 1917 LLVM_DEBUG(dbgs() << " " << HarnessFile << "\n"); 1918 auto Linkable = loadLinkableFile(HarnessFile, S.ES.getTargetTriple(), 1919 LoadArchives::Never); 1920 if (!Linkable) 1921 return Linkable.takeError(); 1922 if (auto Err = S.ObjLayer.add(*S.MainJD, std::move(Linkable->first))) 1923 return Err; 1924 } 1925 return Error::success(); 1926 } 1927 1928 static Error addObjects(Session &S, 1929 const std::map<unsigned, JITDylib *> &IdxToJD, 1930 const DenseSet<unsigned> &LazyLinkIdxs) { 1931 1932 // Load each object into the corresponding JITDylib.. 1933 LLVM_DEBUG(dbgs() << "Adding objects...\n"); 1934 for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end(); 1935 InputFileItr != InputFileEnd; ++InputFileItr) { 1936 unsigned InputFileArgIdx = 1937 InputFiles.getPosition(InputFileItr - InputFiles.begin()); 1938 const std::string &InputFile = *InputFileItr; 1939 if (StringRef(InputFile).ends_with(".a") || 1940 StringRef(InputFile).ends_with(".lib")) 1941 continue; 1942 auto &JD = *std::prev(IdxToJD.lower_bound(InputFileArgIdx))->second; 1943 bool AddLazy = LazyLinkIdxs.count(InputFileArgIdx); 1944 LLVM_DEBUG(dbgs() << " " << InputFileArgIdx << ": \"" << InputFile << "\" " 1945 << (AddLazy ? " (lazy-linked)" : "") << " to " 1946 << JD.getName() << "\n";); 1947 auto ObjBuffer = loadLinkableFile(InputFile, S.ES.getTargetTriple(), 1948 LoadArchives::Never); 1949 if (!ObjBuffer) 1950 return ObjBuffer.takeError(); 1951 1952 if (S.HarnessFiles.empty()) { 1953 if (auto Err = 1954 S.getLinkLayer(AddLazy).add(JD, std::move(ObjBuffer->first))) 1955 return Err; 1956 } else { 1957 // We're in -harness mode. Use a custom interface for this 1958 // test object. 1959 auto ObjInterface = 1960 getTestObjectFileInterface(S, ObjBuffer->first->getMemBufferRef()); 1961 if (!ObjInterface) 1962 return ObjInterface.takeError(); 1963 1964 if (auto Err = S.ObjLayer.add(JD, std::move(ObjBuffer->first), 1965 std::move(*ObjInterface))) 1966 return Err; 1967 } 1968 } 1969 1970 return Error::success(); 1971 } 1972 1973 static Expected<MaterializationUnit::Interface> 1974 getObjectFileInterfaceHidden(ExecutionSession &ES, MemoryBufferRef ObjBuffer) { 1975 auto I = getObjectFileInterface(ES, ObjBuffer); 1976 if (I) { 1977 for (auto &KV : I->SymbolFlags) 1978 KV.second &= ~JITSymbolFlags::Exported; 1979 } 1980 return I; 1981 } 1982 1983 static SmallVector<StringRef, 5> getSearchPathsFromEnvVar(Session &S) { 1984 // FIXME: Handle EPC environment. 1985 SmallVector<StringRef, 5> PathVec; 1986 auto TT = S.ES.getTargetTriple(); 1987 if (TT.isOSBinFormatCOFF()) 1988 StringRef(getenv("PATH")).split(PathVec, ";"); 1989 else if (TT.isOSBinFormatELF()) 1990 StringRef(getenv("LD_LIBRARY_PATH")).split(PathVec, ":"); 1991 1992 return PathVec; 1993 } 1994 1995 static Error addLibraries(Session &S, 1996 const std::map<unsigned, JITDylib *> &IdxToJD, 1997 const DenseSet<unsigned> &LazyLinkIdxs) { 1998 1999 // 1. Collect search paths for each JITDylib. 2000 DenseMap<const JITDylib *, SmallVector<StringRef, 2>> JDSearchPaths; 2001 2002 for (auto LSPItr = LibrarySearchPaths.begin(), 2003 LSPEnd = LibrarySearchPaths.end(); 2004 LSPItr != LSPEnd; ++LSPItr) { 2005 unsigned LibrarySearchPathIdx = 2006 LibrarySearchPaths.getPosition(LSPItr - LibrarySearchPaths.begin()); 2007 auto &JD = *std::prev(IdxToJD.lower_bound(LibrarySearchPathIdx))->second; 2008 2009 StringRef LibrarySearchPath = *LSPItr; 2010 if (sys::fs::get_file_type(LibrarySearchPath) != 2011 sys::fs::file_type::directory_file) 2012 return make_error<StringError>("While linking " + JD.getName() + ", -L" + 2013 LibrarySearchPath + 2014 " does not point to a directory", 2015 inconvertibleErrorCode()); 2016 2017 JDSearchPaths[&JD].push_back(*LSPItr); 2018 } 2019 2020 LLVM_DEBUG({ 2021 if (!JDSearchPaths.empty()) 2022 dbgs() << "Search paths:\n"; 2023 for (auto &KV : JDSearchPaths) { 2024 dbgs() << " " << KV.first->getName() << ": ["; 2025 for (auto &LibSearchPath : KV.second) 2026 dbgs() << " \"" << LibSearchPath << "\""; 2027 dbgs() << " ]\n"; 2028 } 2029 }); 2030 2031 // 2. Collect library loads 2032 struct LibraryLoad { 2033 std::string LibName; 2034 bool IsPath = false; 2035 unsigned Position; 2036 StringRef *CandidateExtensions; 2037 enum { Standard, Hidden } Modifier; 2038 }; 2039 2040 // Queue to load library as in the order as it appears in the argument list. 2041 std::deque<LibraryLoad> LibraryLoadQueue; 2042 // Add archive files from the inputs to LibraryLoads. 2043 for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end(); 2044 InputFileItr != InputFileEnd; ++InputFileItr) { 2045 StringRef InputFile = *InputFileItr; 2046 if (!InputFile.ends_with(".a") && !InputFile.ends_with(".lib")) 2047 continue; 2048 LibraryLoad LL; 2049 LL.LibName = InputFile.str(); 2050 LL.IsPath = true; 2051 LL.Position = InputFiles.getPosition(InputFileItr - InputFiles.begin()); 2052 LL.CandidateExtensions = nullptr; 2053 LL.Modifier = LibraryLoad::Standard; 2054 LibraryLoadQueue.push_back(std::move(LL)); 2055 } 2056 2057 // Add -load_hidden arguments to LibraryLoads. 2058 for (auto LibItr = LoadHidden.begin(), LibEnd = LoadHidden.end(); 2059 LibItr != LibEnd; ++LibItr) { 2060 LibraryLoad LL; 2061 LL.LibName = *LibItr; 2062 LL.IsPath = true; 2063 LL.Position = LoadHidden.getPosition(LibItr - LoadHidden.begin()); 2064 LL.CandidateExtensions = nullptr; 2065 LL.Modifier = LibraryLoad::Hidden; 2066 LibraryLoadQueue.push_back(std::move(LL)); 2067 } 2068 StringRef StandardExtensions[] = {".so", ".dylib", ".dll", ".a", ".lib"}; 2069 StringRef DynLibExtensionsOnly[] = {".so", ".dylib", ".dll"}; 2070 StringRef ArchiveExtensionsOnly[] = {".a", ".lib"}; 2071 2072 // Add -lx arguments to LibraryLoads. 2073 for (auto LibItr = Libraries.begin(), LibEnd = Libraries.end(); 2074 LibItr != LibEnd; ++LibItr) { 2075 LibraryLoad LL; 2076 LL.LibName = *LibItr; 2077 LL.Position = Libraries.getPosition(LibItr - Libraries.begin()); 2078 LL.CandidateExtensions = StandardExtensions; 2079 LL.Modifier = LibraryLoad::Standard; 2080 LibraryLoadQueue.push_back(std::move(LL)); 2081 } 2082 2083 // Add -hidden-lx arguments to LibraryLoads. 2084 for (auto LibHiddenItr = LibrariesHidden.begin(), 2085 LibHiddenEnd = LibrariesHidden.end(); 2086 LibHiddenItr != LibHiddenEnd; ++LibHiddenItr) { 2087 LibraryLoad LL; 2088 LL.LibName = *LibHiddenItr; 2089 LL.Position = 2090 LibrariesHidden.getPosition(LibHiddenItr - LibrariesHidden.begin()); 2091 LL.CandidateExtensions = ArchiveExtensionsOnly; 2092 LL.Modifier = LibraryLoad::Hidden; 2093 LibraryLoadQueue.push_back(std::move(LL)); 2094 } 2095 2096 // If there are any load-<modified> options then turn on flag overrides 2097 // to avoid flag mismatch errors. 2098 if (!LibrariesHidden.empty() || !LoadHidden.empty()) 2099 S.ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true); 2100 2101 // Sort library loads by position in the argument list. 2102 llvm::sort(LibraryLoadQueue, 2103 [](const LibraryLoad &LHS, const LibraryLoad &RHS) { 2104 return LHS.Position < RHS.Position; 2105 }); 2106 2107 // 3. Process library loads. 2108 auto AddArchive = [&](JITDylib &JD, const char *Path, const LibraryLoad &LL) 2109 -> Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> { 2110 StaticLibraryDefinitionGenerator::GetObjectFileInterface 2111 GetObjFileInterface; 2112 switch (LL.Modifier) { 2113 case LibraryLoad::Standard: 2114 GetObjFileInterface = getObjectFileInterface; 2115 break; 2116 case LibraryLoad::Hidden: 2117 GetObjFileInterface = getObjectFileInterfaceHidden; 2118 break; 2119 } 2120 2121 auto &LinkLayer = S.getLinkLayer(LazyLinkIdxs.count(LL.Position)); 2122 2123 StaticLibraryDefinitionGenerator::VisitMembersFunction VisitMembers; 2124 if (AllLoad) 2125 VisitMembers = StaticLibraryDefinitionGenerator::loadAllObjectFileMembers( 2126 LinkLayer, JD); 2127 else if (S.ES.getTargetTriple().isOSBinFormatMachO() && ForceLoadObjC) 2128 VisitMembers = ForceLoadMachOArchiveMembers(LinkLayer, JD, true); 2129 2130 auto G = StaticLibraryDefinitionGenerator::Load( 2131 LinkLayer, Path, std::move(VisitMembers), 2132 std::move(GetObjFileInterface)); 2133 if (!G) 2134 return G.takeError(); 2135 2136 // Push additional dynamic libraries to search. 2137 // Note that this mechanism only happens in COFF. 2138 for (auto FileName : (*G)->getImportedDynamicLibraries()) { 2139 LibraryLoad NewLL; 2140 auto FileNameRef = StringRef(FileName); 2141 if (!FileNameRef.ends_with_insensitive(".dll")) 2142 return make_error<StringError>( 2143 "COFF Imported library not ending with dll extension?", 2144 inconvertibleErrorCode()); 2145 NewLL.LibName = FileNameRef.drop_back(strlen(".dll")).str(); 2146 NewLL.Position = LL.Position; 2147 NewLL.CandidateExtensions = DynLibExtensionsOnly; 2148 NewLL.Modifier = LibraryLoad::Standard; 2149 LibraryLoadQueue.push_front(std::move(NewLL)); 2150 } 2151 return G; 2152 }; 2153 2154 SmallVector<StringRef, 5> SystemSearchPaths; 2155 if (SearchSystemLibrary.getValue()) 2156 SystemSearchPaths = getSearchPathsFromEnvVar(S); 2157 while (!LibraryLoadQueue.empty()) { 2158 bool LibFound = false; 2159 auto LL = LibraryLoadQueue.front(); 2160 LibraryLoadQueue.pop_front(); 2161 auto &JD = *std::prev(IdxToJD.lower_bound(LL.Position))->second; 2162 2163 // If this is the name of a JITDylib then link against that. 2164 if (auto *LJD = S.ES.getJITDylibByName(LL.LibName)) { 2165 JD.addToLinkOrder(*LJD); 2166 continue; 2167 } 2168 2169 if (LL.IsPath) { 2170 auto G = AddArchive(JD, LL.LibName.c_str(), LL); 2171 if (!G) 2172 return createFileError(LL.LibName, G.takeError()); 2173 JD.addGenerator(std::move(*G)); 2174 LLVM_DEBUG({ 2175 dbgs() << "Adding generator for static library " << LL.LibName << " to " 2176 << JD.getName() << "\n"; 2177 }); 2178 continue; 2179 } 2180 2181 // Otherwise look through the search paths. 2182 auto CurJDSearchPaths = JDSearchPaths[&JD]; 2183 for (StringRef SearchPath : 2184 concat<StringRef>(CurJDSearchPaths, SystemSearchPaths)) { 2185 for (const char *LibExt : {".dylib", ".so", ".dll", ".a", ".lib"}) { 2186 SmallVector<char, 256> LibPath; 2187 LibPath.reserve(SearchPath.size() + strlen("lib") + LL.LibName.size() + 2188 strlen(LibExt) + 2); // +2 for pathsep, null term. 2189 llvm::copy(SearchPath, std::back_inserter(LibPath)); 2190 if (StringRef(LibExt) != ".lib" && StringRef(LibExt) != ".dll") 2191 sys::path::append(LibPath, "lib" + LL.LibName + LibExt); 2192 else 2193 sys::path::append(LibPath, LL.LibName + LibExt); 2194 LibPath.push_back('\0'); 2195 2196 // Skip missing or non-regular paths. 2197 if (sys::fs::get_file_type(LibPath.data()) != 2198 sys::fs::file_type::regular_file) { 2199 continue; 2200 } 2201 2202 file_magic Magic; 2203 if (auto EC = identify_magic(LibPath, Magic)) { 2204 // If there was an error loading the file then skip it. 2205 LLVM_DEBUG({ 2206 dbgs() << "Library search found \"" << LibPath 2207 << "\", but could not identify file type (" << EC.message() 2208 << "). Skipping.\n"; 2209 }); 2210 continue; 2211 } 2212 2213 // We identified the magic. Assume that we can load it -- we'll reset 2214 // in the default case. 2215 LibFound = true; 2216 switch (Magic) { 2217 case file_magic::pecoff_executable: 2218 case file_magic::elf_shared_object: 2219 case file_magic::macho_dynamically_linked_shared_lib: { 2220 if (auto Err = S.loadAndLinkDynamicLibrary(JD, LibPath.data())) 2221 return Err; 2222 break; 2223 } 2224 case file_magic::archive: 2225 case file_magic::macho_universal_binary: { 2226 auto G = AddArchive(JD, LibPath.data(), LL); 2227 if (!G) 2228 return G.takeError(); 2229 JD.addGenerator(std::move(*G)); 2230 LLVM_DEBUG({ 2231 dbgs() << "Adding generator for static library " << LibPath.data() 2232 << " to " << JD.getName() << "\n"; 2233 }); 2234 break; 2235 } 2236 default: 2237 // This file isn't a recognized library kind. 2238 LLVM_DEBUG({ 2239 dbgs() << "Library search found \"" << LibPath 2240 << "\", but file type is not supported. Skipping.\n"; 2241 }); 2242 LibFound = false; 2243 break; 2244 } 2245 if (LibFound) 2246 break; 2247 } 2248 if (LibFound) 2249 break; 2250 } 2251 2252 if (!LibFound) 2253 return make_error<StringError>("While linking " + JD.getName() + 2254 ", could not find library for -l" + 2255 LL.LibName, 2256 inconvertibleErrorCode()); 2257 } 2258 2259 // Add platform and process symbols if available. 2260 for (auto &[Idx, JD] : IdxToJD) { 2261 if (S.PlatformJD) 2262 JD->addToLinkOrder(*S.PlatformJD); 2263 if (S.ProcessSymsJD) 2264 JD->addToLinkOrder(*S.ProcessSymsJD); 2265 } 2266 2267 return Error::success(); 2268 } 2269 2270 static Error addSessionInputs(Session &S) { 2271 std::map<unsigned, JITDylib *> IdxToJD; 2272 DenseSet<unsigned> LazyLinkIdxs; 2273 2274 for (auto LLItr = LazyLink.begin(), LLEnd = LazyLink.end(); LLItr != LLEnd; 2275 ++LLItr) { 2276 if (*LLItr) 2277 LazyLinkIdxs.insert(LazyLink.getPosition(LLItr - LazyLink.begin()) + 1); 2278 } 2279 2280 if (auto Err = createJITDylibs(S, IdxToJD)) 2281 return Err; 2282 2283 if (auto Err = addAbsoluteSymbols(S, IdxToJD)) 2284 return Err; 2285 2286 if (auto Err = addAliases(S, IdxToJD)) 2287 return Err; 2288 2289 if (auto Err = addSectCreates(S, IdxToJD)) 2290 return Err; 2291 2292 if (!TestHarnesses.empty()) 2293 if (auto Err = addTestHarnesses(S)) 2294 return Err; 2295 2296 if (auto Err = addObjects(S, IdxToJD, LazyLinkIdxs)) 2297 return Err; 2298 2299 if (auto Err = addLibraries(S, IdxToJD, LazyLinkIdxs)) 2300 return Err; 2301 2302 return Error::success(); 2303 } 2304 2305 namespace { 2306 struct TargetInfo { 2307 const Target *TheTarget; 2308 std::unique_ptr<MCSubtargetInfo> STI; 2309 std::unique_ptr<MCRegisterInfo> MRI; 2310 std::unique_ptr<MCAsmInfo> MAI; 2311 std::unique_ptr<MCContext> Ctx; 2312 std::unique_ptr<MCDisassembler> Disassembler; 2313 std::unique_ptr<MCInstrInfo> MII; 2314 std::unique_ptr<MCInstrAnalysis> MIA; 2315 std::unique_ptr<MCInstPrinter> InstPrinter; 2316 }; 2317 } // anonymous namespace 2318 2319 static TargetInfo 2320 getTargetInfo(const Triple &TT, 2321 const SubtargetFeatures &TF = SubtargetFeatures()) { 2322 auto TripleName = TT.str(); 2323 std::string ErrorStr; 2324 const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, ErrorStr); 2325 if (!TheTarget) 2326 ExitOnErr(make_error<StringError>("Error accessing target '" + TripleName + 2327 "': " + ErrorStr, 2328 inconvertibleErrorCode())); 2329 2330 std::unique_ptr<MCSubtargetInfo> STI( 2331 TheTarget->createMCSubtargetInfo(TripleName, "", TF.getString())); 2332 if (!STI) 2333 ExitOnErr( 2334 make_error<StringError>("Unable to create subtarget for " + TripleName, 2335 inconvertibleErrorCode())); 2336 2337 std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName)); 2338 if (!MRI) 2339 ExitOnErr(make_error<StringError>("Unable to create target register info " 2340 "for " + 2341 TripleName, 2342 inconvertibleErrorCode())); 2343 2344 MCTargetOptions MCOptions; 2345 std::unique_ptr<MCAsmInfo> MAI( 2346 TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions)); 2347 if (!MAI) 2348 ExitOnErr(make_error<StringError>("Unable to create target asm info " + 2349 TripleName, 2350 inconvertibleErrorCode())); 2351 2352 auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(), 2353 MRI.get(), STI.get()); 2354 2355 std::unique_ptr<MCDisassembler> Disassembler( 2356 TheTarget->createMCDisassembler(*STI, *Ctx)); 2357 if (!Disassembler) 2358 ExitOnErr(make_error<StringError>("Unable to create disassembler for " + 2359 TripleName, 2360 inconvertibleErrorCode())); 2361 2362 std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo()); 2363 if (!MII) 2364 ExitOnErr(make_error<StringError>("Unable to create instruction info for" + 2365 TripleName, 2366 inconvertibleErrorCode())); 2367 2368 std::unique_ptr<MCInstrAnalysis> MIA( 2369 TheTarget->createMCInstrAnalysis(MII.get())); 2370 if (!MIA) 2371 ExitOnErr(make_error<StringError>( 2372 "Unable to create instruction analysis for" + TripleName, 2373 inconvertibleErrorCode())); 2374 2375 std::unique_ptr<MCInstPrinter> InstPrinter( 2376 TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI)); 2377 if (!InstPrinter) 2378 ExitOnErr(make_error<StringError>( 2379 "Unable to create instruction printer for" + TripleName, 2380 inconvertibleErrorCode())); 2381 return {TheTarget, std::move(STI), std::move(MRI), 2382 std::move(MAI), std::move(Ctx), std::move(Disassembler), 2383 std::move(MII), std::move(MIA), std::move(InstPrinter)}; 2384 } 2385 static Error runChecks(Session &S, Triple TT, SubtargetFeatures Features) { 2386 if (CheckFiles.empty()) 2387 return Error::success(); 2388 2389 S.waitForFilesLinkedFromEntryPointFile(); 2390 2391 LLVM_DEBUG(dbgs() << "Running checks...\n"); 2392 2393 auto IsSymbolValid = [&S](StringRef Symbol) { 2394 auto InternedSymbol = S.ES.getSymbolStringPool()->intern(Symbol); 2395 return S.isSymbolRegistered(InternedSymbol); 2396 }; 2397 2398 auto GetSymbolInfo = [&S](StringRef Symbol) { 2399 auto InternedSymbol = S.ES.getSymbolStringPool()->intern(Symbol); 2400 return S.findSymbolInfo(InternedSymbol, "Can not get symbol info"); 2401 }; 2402 2403 auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) { 2404 return S.findSectionInfo(FileName, SectionName); 2405 }; 2406 2407 auto GetStubInfo = [&S](StringRef FileName, StringRef SectionName, 2408 StringRef KindNameFilter) { 2409 return S.findStubInfo(FileName, SectionName, KindNameFilter); 2410 }; 2411 2412 auto GetGOTInfo = [&S](StringRef FileName, StringRef SectionName) { 2413 return S.findGOTEntryInfo(FileName, SectionName); 2414 }; 2415 2416 RuntimeDyldChecker Checker( 2417 IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo, 2418 S.ES.getTargetTriple().isLittleEndian() ? llvm::endianness::little 2419 : llvm::endianness::big, 2420 TT, StringRef(), Features, dbgs()); 2421 2422 std::string CheckLineStart = "# " + CheckName + ":"; 2423 for (auto &CheckFile : CheckFiles) { 2424 auto CheckerFileBuf = ExitOnErr(getFile(CheckFile)); 2425 if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf)) 2426 ExitOnErr(make_error<StringError>( 2427 "Some checks in " + CheckFile + " failed", inconvertibleErrorCode())); 2428 } 2429 2430 return Error::success(); 2431 } 2432 2433 static Error addSelfRelocations(LinkGraph &G) { 2434 auto TI = getTargetInfo(G.getTargetTriple()); 2435 for (auto *Sym : G.defined_symbols()) 2436 if (Sym->isCallable()) 2437 if (auto Err = addFunctionPointerRelocationsToCurrentSymbol( 2438 *Sym, G, *TI.Disassembler, *TI.MIA)) 2439 return Err; 2440 return Error::success(); 2441 } 2442 2443 static Expected<ExecutorSymbolDef> getMainEntryPoint(Session &S) { 2444 return S.ES.lookup(S.JDSearchOrder, S.ES.intern(EntryPointName)); 2445 } 2446 2447 static Expected<ExecutorSymbolDef> getOrcRuntimeEntryPoint(Session &S) { 2448 std::string RuntimeEntryPoint = "__orc_rt_run_program_wrapper"; 2449 if (S.ES.getTargetTriple().getObjectFormat() == Triple::MachO) 2450 RuntimeEntryPoint = '_' + RuntimeEntryPoint; 2451 return S.ES.lookup(S.JDSearchOrder, S.ES.intern(RuntimeEntryPoint)); 2452 } 2453 2454 static Expected<ExecutorSymbolDef> getEntryPoint(Session &S) { 2455 ExecutorSymbolDef EntryPoint; 2456 2457 // Find the entry-point function unconditionally, since we want to force 2458 // it to be materialized to collect stats. 2459 if (auto EP = getMainEntryPoint(S)) 2460 EntryPoint = *EP; 2461 else 2462 return EP.takeError(); 2463 LLVM_DEBUG({ 2464 dbgs() << "Using entry point \"" << EntryPointName 2465 << "\": " << formatv("{0:x16}", EntryPoint.getAddress()) << "\n"; 2466 }); 2467 2468 // If we're running with the ORC runtime then replace the entry-point 2469 // with the __orc_rt_run_program symbol. 2470 if (!OrcRuntime.empty()) { 2471 if (auto EP = getOrcRuntimeEntryPoint(S)) 2472 EntryPoint = *EP; 2473 else 2474 return EP.takeError(); 2475 LLVM_DEBUG({ 2476 dbgs() << "(called via __orc_rt_run_program_wrapper at " 2477 << formatv("{0:x16}", EntryPoint.getAddress()) << ")\n"; 2478 }); 2479 } 2480 2481 return EntryPoint; 2482 } 2483 2484 static Expected<int> runWithRuntime(Session &S, ExecutorAddr EntryPointAddr) { 2485 StringRef DemangledEntryPoint = EntryPointName; 2486 if (S.ES.getTargetTriple().getObjectFormat() == Triple::MachO && 2487 DemangledEntryPoint.front() == '_') 2488 DemangledEntryPoint = DemangledEntryPoint.drop_front(); 2489 using llvm::orc::shared::SPSString; 2490 using SPSRunProgramSig = 2491 int64_t(SPSString, SPSString, shared::SPSSequence<SPSString>); 2492 int64_t Result; 2493 if (auto Err = S.ES.callSPSWrapper<SPSRunProgramSig>( 2494 EntryPointAddr, Result, S.MainJD->getName(), DemangledEntryPoint, 2495 static_cast<std::vector<std::string> &>(InputArgv))) 2496 return std::move(Err); 2497 return Result; 2498 } 2499 2500 static Expected<int> runWithoutRuntime(Session &S, 2501 ExecutorAddr EntryPointAddr) { 2502 return S.ES.getExecutorProcessControl().runAsMain(EntryPointAddr, InputArgv); 2503 } 2504 2505 namespace { 2506 struct JITLinkTimers { 2507 TimerGroup JITLinkTG{"llvm-jitlink timers", "timers for llvm-jitlink phases"}; 2508 Timer LoadObjectsTimer{"load", "time to load/add object files", JITLinkTG}; 2509 Timer LinkTimer{"link", "time to link object files", JITLinkTG}; 2510 Timer RunTimer{"run", "time to execute jitlink'd code", JITLinkTG}; 2511 }; 2512 } // namespace 2513 2514 int main(int argc, char *argv[]) { 2515 InitLLVM X(argc, argv); 2516 2517 InitializeAllTargetInfos(); 2518 InitializeAllTargetMCs(); 2519 InitializeAllDisassemblers(); 2520 2521 cl::HideUnrelatedOptions({&JITLinkCategory, &getColorCategory()}); 2522 cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool"); 2523 ExitOnErr.setBanner(std::string(argv[0]) + ": "); 2524 2525 /// If timers are enabled, create a JITLinkTimers instance. 2526 std::unique_ptr<JITLinkTimers> Timers = 2527 ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr; 2528 2529 auto [TT, Features] = getFirstFileTripleAndFeatures(); 2530 ExitOnErr(sanitizeArguments(TT, argv[0])); 2531 2532 auto S = ExitOnErr(Session::Create(TT, Features)); 2533 2534 enableStatistics(*S, !OrcRuntime.empty()); 2535 2536 { 2537 TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr); 2538 ExitOnErr(addSessionInputs(*S)); 2539 } 2540 2541 if (PhonyExternals) 2542 addPhonyExternalsGenerator(*S); 2543 2544 if (ShowInitialExecutionSessionState) 2545 S->ES.dump(outs()); 2546 2547 Expected<ExecutorSymbolDef> EntryPoint((ExecutorSymbolDef())); 2548 { 2549 ExpectedAsOutParameter<ExecutorSymbolDef> _(&EntryPoint); 2550 TimeRegion TR(Timers ? &Timers->LinkTimer : nullptr); 2551 EntryPoint = getEntryPoint(*S); 2552 } 2553 2554 // Print any reports regardless of whether we succeeded or failed. 2555 if (ShowEntryExecutionSessionState) 2556 S->ES.dump(outs()); 2557 2558 if (ShowAddrs) 2559 S->dumpSessionInfo(outs()); 2560 2561 if (!EntryPoint) { 2562 if (Timers) 2563 Timers->JITLinkTG.printAll(errs()); 2564 reportLLVMJITLinkError(EntryPoint.takeError()); 2565 exit(1); 2566 } 2567 2568 ExitOnErr(runChecks(*S, std::move(TT), std::move(Features))); 2569 2570 int Result = 0; 2571 if (!NoExec) { 2572 LLVM_DEBUG(dbgs() << "Running \"" << EntryPointName << "\"...\n"); 2573 TimeRegion TR(Timers ? &Timers->RunTimer : nullptr); 2574 if (!OrcRuntime.empty()) 2575 Result = 2576 ExitOnErr(runWithRuntime(*S, ExecutorAddr(EntryPoint->getAddress()))); 2577 else 2578 Result = ExitOnErr( 2579 runWithoutRuntime(*S, ExecutorAddr(EntryPoint->getAddress()))); 2580 } 2581 2582 // Destroy the session. 2583 ExitOnErr(S->ES.endSession()); 2584 S.reset(); 2585 2586 if (Timers) 2587 Timers->JITLinkTG.printAll(errs()); 2588 2589 // If the executing code set a test result override then use that. 2590 if (UseTestResultOverride) 2591 Result = TestResultOverride; 2592 2593 return Result; 2594 } 2595