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