LLVM 19.0.0git
COFFPlatform.cpp
Go to the documentation of this file.
1//===------- COFFPlatform.cpp - Utilities for executing COFF in Orc -------===//
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
14
15#include "llvm/Object/COFF.h"
16
18
20
21#define DEBUG_TYPE "orc"
22
23using namespace llvm;
24using namespace llvm::orc;
25using namespace llvm::orc::shared;
26
27namespace llvm {
28namespace orc {
29namespace shared {
30
40
41} // namespace shared
42} // namespace orc
43} // namespace llvm
44namespace {
45
46class COFFHeaderMaterializationUnit : public MaterializationUnit {
47public:
48 COFFHeaderMaterializationUnit(COFFPlatform &CP,
49 const SymbolStringPtr &HeaderStartSymbol)
50 : MaterializationUnit(createHeaderInterface(CP, HeaderStartSymbol)),
51 CP(CP) {}
52
53 StringRef getName() const override { return "COFFHeaderMU"; }
54
55 void materialize(std::unique_ptr<MaterializationResponsibility> R) override {
56 unsigned PointerSize;
58 const auto &TT = CP.getExecutionSession().getTargetTriple();
59
60 switch (TT.getArch()) {
61 case Triple::x86_64:
62 PointerSize = 8;
64 break;
65 default:
66 llvm_unreachable("Unrecognized architecture");
67 }
68
69 auto G = std::make_unique<jitlink::LinkGraph>(
70 "<COFFHeaderMU>", TT, PointerSize, Endianness,
72 auto &HeaderSection = G->createSection("__header", MemProt::Read);
73 auto &HeaderBlock = createHeaderBlock(*G, HeaderSection);
74
75 // Init symbol is __ImageBase symbol.
76 auto &ImageBaseSymbol = G->addDefinedSymbol(
77 HeaderBlock, 0, *R->getInitializerSymbol(), HeaderBlock.getSize(),
78 jitlink::Linkage::Strong, jitlink::Scope::Default, false, true);
79
80 addImageBaseRelocationEdge(HeaderBlock, ImageBaseSymbol);
81
82 CP.getObjectLinkingLayer().emit(std::move(R), std::move(G));
83 }
84
85 void discard(const JITDylib &JD, const SymbolStringPtr &Sym) override {}
86
87private:
88 struct HeaderSymbol {
89 const char *Name;
91 };
92
93 struct NTHeader {
95 object::coff_file_header FileHeader;
96 struct PEHeader {
99 } OptionalHeader;
100 };
101
102 struct HeaderBlockContent {
103 object::dos_header DOSHeader;
104 COFFHeaderMaterializationUnit::NTHeader NTHeader;
105 };
106
108 jitlink::Section &HeaderSection) {
109 HeaderBlockContent Hdr = {};
110
111 // Set up magic
112 Hdr.DOSHeader.Magic[0] = 'M';
113 Hdr.DOSHeader.Magic[1] = 'Z';
114 Hdr.DOSHeader.AddressOfNewExeHeader =
115 offsetof(HeaderBlockContent, NTHeader);
116 uint32_t PEMagic = *reinterpret_cast<const uint32_t *>(COFF::PEMagic);
117 Hdr.NTHeader.PEMagic = PEMagic;
118 Hdr.NTHeader.OptionalHeader.Header.Magic = COFF::PE32Header::PE32_PLUS;
119
120 switch (G.getTargetTriple().getArch()) {
121 case Triple::x86_64:
122 Hdr.NTHeader.FileHeader.Machine = COFF::IMAGE_FILE_MACHINE_AMD64;
123 break;
124 default:
125 llvm_unreachable("Unrecognized architecture");
126 }
127
128 auto HeaderContent = G.allocateContent(
129 ArrayRef<char>(reinterpret_cast<const char *>(&Hdr), sizeof(Hdr)));
130
131 return G.createContentBlock(HeaderSection, HeaderContent, ExecutorAddr(), 8,
132 0);
133 }
134
135 static void addImageBaseRelocationEdge(jitlink::Block &B,
136 jitlink::Symbol &ImageBase) {
137 auto ImageBaseOffset = offsetof(HeaderBlockContent, NTHeader) +
138 offsetof(NTHeader, OptionalHeader) +
140 B.addEdge(jitlink::x86_64::Pointer64, ImageBaseOffset, ImageBase, 0);
141 }
142
144 createHeaderInterface(COFFPlatform &MOP,
145 const SymbolStringPtr &HeaderStartSymbol) {
146 SymbolFlagsMap HeaderSymbolFlags;
147
148 HeaderSymbolFlags[HeaderStartSymbol] = JITSymbolFlags::Exported;
149
150 return MaterializationUnit::Interface(std::move(HeaderSymbolFlags),
151 HeaderStartSymbol);
152 }
153
155};
156
157} // end anonymous namespace
158
159namespace llvm {
160namespace orc {
161
163 ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
164 JITDylib &PlatformJD, std::unique_ptr<MemoryBuffer> OrcRuntimeArchiveBuffer,
165 LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime,
166 const char *VCRuntimePath, std::optional<SymbolAliasMap> RuntimeAliases) {
167
168 // If the target is not supported then bail out immediately.
169 if (!supportedTarget(ES.getTargetTriple()))
170 return make_error<StringError>("Unsupported COFFPlatform triple: " +
171 ES.getTargetTriple().str(),
173
174 auto &EPC = ES.getExecutorProcessControl();
175
176 auto GeneratorArchive =
177 object::Archive::create(OrcRuntimeArchiveBuffer->getMemBufferRef());
178 if (!GeneratorArchive)
179 return GeneratorArchive.takeError();
180
181 auto OrcRuntimeArchiveGenerator = StaticLibraryDefinitionGenerator::Create(
182 ObjLinkingLayer, nullptr, std::move(*GeneratorArchive));
183 if (!OrcRuntimeArchiveGenerator)
184 return OrcRuntimeArchiveGenerator.takeError();
185
186 // We need a second instance of the archive (for now) for the Platform. We
187 // can `cantFail` this call, since if it were going to fail it would have
188 // failed above.
189 auto RuntimeArchive = cantFail(
190 object::Archive::create(OrcRuntimeArchiveBuffer->getMemBufferRef()));
191
192 // Create default aliases if the caller didn't supply any.
193 if (!RuntimeAliases)
194 RuntimeAliases = standardPlatformAliases(ES);
195
196 // Define the aliases.
197 if (auto Err = PlatformJD.define(symbolAliases(std::move(*RuntimeAliases))))
198 return std::move(Err);
199
200 auto &HostFuncJD = ES.createBareJITDylib("$<PlatformRuntimeHostFuncJD>");
201
202 // Add JIT-dispatch function support symbols.
203 if (auto Err = HostFuncJD.define(
204 absoluteSymbols({{ES.intern("__orc_rt_jit_dispatch"),
205 {EPC.getJITDispatchInfo().JITDispatchFunction,
207 {ES.intern("__orc_rt_jit_dispatch_ctx"),
208 {EPC.getJITDispatchInfo().JITDispatchContext,
210 return std::move(Err);
211
212 PlatformJD.addToLinkOrder(HostFuncJD);
213
214 // Create the instance.
215 Error Err = Error::success();
216 auto P = std::unique_ptr<COFFPlatform>(new COFFPlatform(
217 ES, ObjLinkingLayer, PlatformJD, std::move(*OrcRuntimeArchiveGenerator),
218 std::move(OrcRuntimeArchiveBuffer), std::move(RuntimeArchive),
219 std::move(LoadDynLibrary), StaticVCRuntime, VCRuntimePath, Err));
220 if (Err)
221 return std::move(Err);
222 return std::move(P);
223}
224
227 JITDylib &PlatformJD, const char *OrcRuntimePath,
228 LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime,
229 const char *VCRuntimePath,
230 std::optional<SymbolAliasMap> RuntimeAliases) {
231
232 auto ArchiveBuffer = MemoryBuffer::getFile(OrcRuntimePath);
233 if (!ArchiveBuffer)
234 return createFileError(OrcRuntimePath, ArchiveBuffer.getError());
235
236 return Create(ES, ObjLinkingLayer, PlatformJD, std::move(*ArchiveBuffer),
237 std::move(LoadDynLibrary), StaticVCRuntime, VCRuntimePath,
238 std::move(RuntimeAliases));
239}
240
241Expected<MemoryBufferRef> COFFPlatform::getPerJDObjectFile() {
242 auto PerJDObj = OrcRuntimeArchive->findSym("__orc_rt_coff_per_jd_marker");
243 if (!PerJDObj)
244 return PerJDObj.takeError();
245
246 if (!*PerJDObj)
247 return make_error<StringError>("Could not find per jd object file",
249
250 auto Buffer = (*PerJDObj)->getAsBinary();
251 if (!Buffer)
252 return Buffer.takeError();
253
254 return (*Buffer)->getMemoryBufferRef();
255}
256
258 ArrayRef<std::pair<const char *, const char *>> AL) {
259 for (auto &KV : AL) {
260 auto AliasName = ES.intern(KV.first);
261 assert(!Aliases.count(AliasName) && "Duplicate symbol name in alias map");
262 Aliases[std::move(AliasName)] = {ES.intern(KV.second),
264 }
265}
266
268 if (auto Err = JD.define(std::make_unique<COFFHeaderMaterializationUnit>(
269 *this, COFFHeaderStartSymbol)))
270 return Err;
271
272 if (auto Err = ES.lookup({&JD}, COFFHeaderStartSymbol).takeError())
273 return Err;
274
275 // Define the CXX aliases.
276 SymbolAliasMap CXXAliases;
277 addAliases(ES, CXXAliases, requiredCXXAliases());
278 if (auto Err = JD.define(symbolAliases(std::move(CXXAliases))))
279 return Err;
280
281 auto PerJDObj = getPerJDObjectFile();
282 if (!PerJDObj)
283 return PerJDObj.takeError();
284
285 auto I = getObjectFileInterface(ES, *PerJDObj);
286 if (!I)
287 return I.takeError();
288
289 if (auto Err = ObjLinkingLayer.add(
290 JD, MemoryBuffer::getMemBuffer(*PerJDObj, false), std::move(*I)))
291 return Err;
292
293 if (!Bootstrapping) {
294 auto ImportedLibs = StaticVCRuntime
295 ? VCRuntimeBootstrap->loadStaticVCRuntime(JD)
296 : VCRuntimeBootstrap->loadDynamicVCRuntime(JD);
297 if (!ImportedLibs)
298 return ImportedLibs.takeError();
299 for (auto &Lib : *ImportedLibs)
300 if (auto Err = LoadDynLibrary(JD, Lib))
301 return Err;
302 if (StaticVCRuntime)
303 if (auto Err = VCRuntimeBootstrap->initializeStaticVCRuntime(JD))
304 return Err;
305 }
306
307 JD.addGenerator(DLLImportDefinitionGenerator::Create(ES, ObjLinkingLayer));
308 return Error::success();
309}
310
312 std::lock_guard<std::mutex> Lock(PlatformMutex);
313 auto I = JITDylibToHeaderAddr.find(&JD);
314 if (I != JITDylibToHeaderAddr.end()) {
315 assert(HeaderAddrToJITDylib.count(I->second) &&
316 "HeaderAddrToJITDylib missing entry");
317 HeaderAddrToJITDylib.erase(I->second);
318 JITDylibToHeaderAddr.erase(I);
319 }
320 return Error::success();
321}
322
324 const MaterializationUnit &MU) {
325 auto &JD = RT.getJITDylib();
326 const auto &InitSym = MU.getInitializerSymbol();
327 if (!InitSym)
328 return Error::success();
329
330 RegisteredInitSymbols[&JD].add(InitSym,
332
333 LLVM_DEBUG({
334 dbgs() << "COFFPlatform: Registered init symbol " << *InitSym << " for MU "
335 << MU.getName() << "\n";
336 });
337 return Error::success();
338}
339
341 llvm_unreachable("Not supported yet");
342}
343
345 SymbolAliasMap Aliases;
347 return Aliases;
348}
349
352 static const std::pair<const char *, const char *> RequiredCXXAliases[] = {
353 {"_CxxThrowException", "__orc_rt_coff_cxx_throw_exception"},
354 {"_onexit", "__orc_rt_coff_onexit_per_jd"},
355 {"atexit", "__orc_rt_coff_atexit_per_jd"}};
356
357 return ArrayRef<std::pair<const char *, const char *>>(RequiredCXXAliases);
358}
359
362 static const std::pair<const char *, const char *>
363 StandardRuntimeUtilityAliases[] = {
364 {"__orc_rt_run_program", "__orc_rt_coff_run_program"},
365 {"__orc_rt_jit_dlerror", "__orc_rt_coff_jit_dlerror"},
366 {"__orc_rt_jit_dlopen", "__orc_rt_coff_jit_dlopen"},
367 {"__orc_rt_jit_dlclose", "__orc_rt_coff_jit_dlclose"},
368 {"__orc_rt_jit_dlsym", "__orc_rt_coff_jit_dlsym"},
369 {"__orc_rt_log_error", "__orc_rt_log_error_to_stderr"}};
370
372 StandardRuntimeUtilityAliases);
373}
374
375bool COFFPlatform::supportedTarget(const Triple &TT) {
376 switch (TT.getArch()) {
377 case Triple::x86_64:
378 return true;
379 default:
380 return false;
381 }
382}
383
384COFFPlatform::COFFPlatform(
385 ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
386 JITDylib &PlatformJD,
387 std::unique_ptr<StaticLibraryDefinitionGenerator> OrcRuntimeGenerator,
388 std::unique_ptr<MemoryBuffer> OrcRuntimeArchiveBuffer,
389 std::unique_ptr<object::Archive> OrcRuntimeArchive,
390 LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime,
391 const char *VCRuntimePath, Error &Err)
392 : ES(ES), ObjLinkingLayer(ObjLinkingLayer),
393 LoadDynLibrary(std::move(LoadDynLibrary)),
394 OrcRuntimeArchiveBuffer(std::move(OrcRuntimeArchiveBuffer)),
395 OrcRuntimeArchive(std::move(OrcRuntimeArchive)),
396 StaticVCRuntime(StaticVCRuntime),
397 COFFHeaderStartSymbol(ES.intern("__ImageBase")) {
399
400 Bootstrapping.store(true);
401 ObjLinkingLayer.addPlugin(std::make_unique<COFFPlatformPlugin>(*this));
402
403 // Load vc runtime
404 auto VCRT =
405 COFFVCRuntimeBootstrapper::Create(ES, ObjLinkingLayer, VCRuntimePath);
406 if (!VCRT) {
407 Err = VCRT.takeError();
408 return;
409 }
410 VCRuntimeBootstrap = std::move(*VCRT);
411
412 for (auto &Lib : OrcRuntimeGenerator->getImportedDynamicLibraries())
413 DylibsToPreload.insert(Lib);
414
415 auto ImportedLibs =
416 StaticVCRuntime ? VCRuntimeBootstrap->loadStaticVCRuntime(PlatformJD)
417 : VCRuntimeBootstrap->loadDynamicVCRuntime(PlatformJD);
418 if (!ImportedLibs) {
419 Err = ImportedLibs.takeError();
420 return;
421 }
422
423 for (auto &Lib : *ImportedLibs)
424 DylibsToPreload.insert(Lib);
425
426 PlatformJD.addGenerator(std::move(OrcRuntimeGenerator));
427
428 // PlatformJD hasn't been set up by the platform yet (since we're creating
429 // the platform now), so set it up.
430 if (auto E2 = setupJITDylib(PlatformJD)) {
431 Err = std::move(E2);
432 return;
433 }
434
435 for (auto& Lib : DylibsToPreload)
436 if (auto E2 = this->LoadDynLibrary(PlatformJD, Lib)) {
437 Err = std::move(E2);
438 return;
439 }
440
441 if (StaticVCRuntime)
442 if (auto E2 = VCRuntimeBootstrap->initializeStaticVCRuntime(PlatformJD)) {
443 Err = std::move(E2);
444 return;
445 }
446
447 // Associate wrapper function tags with JIT-side function implementations.
448 if (auto E2 = associateRuntimeSupportFunctions(PlatformJD)) {
449 Err = std::move(E2);
450 return;
451 }
452
453 // Lookup addresses of runtime functions callable by the platform,
454 // call the platform bootstrap function to initialize the platform-state
455 // object in the executor.
456 if (auto E2 = bootstrapCOFFRuntime(PlatformJD)) {
457 Err = std::move(E2);
458 return;
459 }
460
461 Bootstrapping.store(false);
462 JDBootstrapStates.clear();
463}
464
466COFFPlatform::buildJDDepMap(JITDylib &JD) {
467 return ES.runSessionLocked([&]() -> Expected<JITDylibDepMap> {
468 JITDylibDepMap JDDepMap;
469
470 SmallVector<JITDylib *, 16> Worklist({&JD});
471 while (!Worklist.empty()) {
472 auto CurJD = Worklist.back();
473 Worklist.pop_back();
474
475 auto &DM = JDDepMap[CurJD];
476 CurJD->withLinkOrderDo([&](const JITDylibSearchOrder &O) {
477 DM.reserve(O.size());
478 for (auto &KV : O) {
479 if (KV.first == CurJD)
480 continue;
481 {
482 // Bare jitdylibs not known to the platform
483 std::lock_guard<std::mutex> Lock(PlatformMutex);
484 if (!JITDylibToHeaderAddr.count(KV.first)) {
485 LLVM_DEBUG({
486 dbgs() << "JITDylib unregistered to COFFPlatform detected in "
487 "LinkOrder: "
488 << CurJD->getName() << "\n";
489 });
490 continue;
491 }
492 }
493 DM.push_back(KV.first);
494 // Push unvisited entry.
495 if (!JDDepMap.count(KV.first)) {
496 Worklist.push_back(KV.first);
497 JDDepMap[KV.first] = {};
498 }
499 }
500 });
501 }
502 return std::move(JDDepMap);
503 });
504}
505
506void COFFPlatform::pushInitializersLoop(PushInitializersSendResultFn SendResult,
507 JITDylibSP JD,
508 JITDylibDepMap &JDDepMap) {
509 SmallVector<JITDylib *, 16> Worklist({JD.get()});
510 DenseSet<JITDylib *> Visited({JD.get()});
512 ES.runSessionLocked([&]() {
513 while (!Worklist.empty()) {
514 auto CurJD = Worklist.back();
515 Worklist.pop_back();
516
517 auto RISItr = RegisteredInitSymbols.find(CurJD);
518 if (RISItr != RegisteredInitSymbols.end()) {
519 NewInitSymbols[CurJD] = std::move(RISItr->second);
520 RegisteredInitSymbols.erase(RISItr);
521 }
522
523 for (auto *DepJD : JDDepMap[CurJD])
524 if (!Visited.count(DepJD)) {
525 Worklist.push_back(DepJD);
526 Visited.insert(DepJD);
527 }
528 }
529 });
530
531 // If there are no further init symbols to look up then send the link order
532 // (as a list of header addresses) to the caller.
533 if (NewInitSymbols.empty()) {
534 // Build the dep info map to return.
535 COFFJITDylibDepInfoMap DIM;
536 DIM.reserve(JDDepMap.size());
537 for (auto &KV : JDDepMap) {
538 std::lock_guard<std::mutex> Lock(PlatformMutex);
539 COFFJITDylibDepInfo DepInfo;
540 DepInfo.reserve(KV.second.size());
541 for (auto &Dep : KV.second) {
542 DepInfo.push_back(JITDylibToHeaderAddr[Dep]);
543 }
544 auto H = JITDylibToHeaderAddr[KV.first];
545 DIM.push_back(std::make_pair(H, std::move(DepInfo)));
546 }
547 SendResult(DIM);
548 return;
549 }
550
551 // Otherwise issue a lookup and re-run this phase when it completes.
552 lookupInitSymbolsAsync(
553 [this, SendResult = std::move(SendResult), &JD,
554 JDDepMap = std::move(JDDepMap)](Error Err) mutable {
555 if (Err)
556 SendResult(std::move(Err));
557 else
558 pushInitializersLoop(std::move(SendResult), JD, JDDepMap);
559 },
560 ES, std::move(NewInitSymbols));
561}
562
563void COFFPlatform::rt_pushInitializers(PushInitializersSendResultFn SendResult,
564 ExecutorAddr JDHeaderAddr) {
565 JITDylibSP JD;
566 {
567 std::lock_guard<std::mutex> Lock(PlatformMutex);
568 auto I = HeaderAddrToJITDylib.find(JDHeaderAddr);
569 if (I != HeaderAddrToJITDylib.end())
570 JD = I->second;
571 }
572
573 LLVM_DEBUG({
574 dbgs() << "COFFPlatform::rt_pushInitializers(" << JDHeaderAddr << ") ";
575 if (JD)
576 dbgs() << "pushing initializers for " << JD->getName() << "\n";
577 else
578 dbgs() << "No JITDylib for header address.\n";
579 });
580
581 if (!JD) {
582 SendResult(make_error<StringError>("No JITDylib with header addr " +
583 formatv("{0:x}", JDHeaderAddr),
585 return;
586 }
587
588 auto JDDepMap = buildJDDepMap(*JD);
589 if (!JDDepMap) {
590 SendResult(JDDepMap.takeError());
591 return;
592 }
593
594 pushInitializersLoop(std::move(SendResult), JD, *JDDepMap);
595}
596
597void COFFPlatform::rt_lookupSymbol(SendSymbolAddressFn SendResult,
598 ExecutorAddr Handle, StringRef SymbolName) {
599 LLVM_DEBUG(dbgs() << "COFFPlatform::rt_lookupSymbol(\"" << Handle << "\")\n");
600
601 JITDylib *JD = nullptr;
602
603 {
604 std::lock_guard<std::mutex> Lock(PlatformMutex);
605 auto I = HeaderAddrToJITDylib.find(Handle);
606 if (I != HeaderAddrToJITDylib.end())
607 JD = I->second;
608 }
609
610 if (!JD) {
611 LLVM_DEBUG(dbgs() << " No JITDylib for handle " << Handle << "\n");
612 SendResult(make_error<StringError>("No JITDylib associated with handle " +
613 formatv("{0:x}", Handle),
615 return;
616 }
617
618 // Use functor class to work around XL build compiler issue on AIX.
619 class RtLookupNotifyComplete {
620 public:
621 RtLookupNotifyComplete(SendSymbolAddressFn &&SendResult)
622 : SendResult(std::move(SendResult)) {}
623 void operator()(Expected<SymbolMap> Result) {
624 if (Result) {
625 assert(Result->size() == 1 && "Unexpected result map count");
626 SendResult(Result->begin()->second.getAddress());
627 } else {
628 SendResult(Result.takeError());
629 }
630 }
631
632 private:
633 SendSymbolAddressFn SendResult;
634 };
635
636 ES.lookup(
639 RtLookupNotifyComplete(std::move(SendResult)), NoDependenciesToRegister);
640}
641
642Error COFFPlatform::associateRuntimeSupportFunctions(JITDylib &PlatformJD) {
644
645 using LookupSymbolSPSSig =
647 WFs[ES.intern("__orc_rt_coff_symbol_lookup_tag")] =
648 ES.wrapAsyncWithSPS<LookupSymbolSPSSig>(this,
649 &COFFPlatform::rt_lookupSymbol);
650 using PushInitializersSPSSig =
652 WFs[ES.intern("__orc_rt_coff_push_initializers_tag")] =
653 ES.wrapAsyncWithSPS<PushInitializersSPSSig>(
654 this, &COFFPlatform::rt_pushInitializers);
655
656 return ES.registerJITDispatchHandlers(PlatformJD, std::move(WFs));
657}
658
659Error COFFPlatform::runBootstrapInitializers(JDBootstrapState &BState) {
660 llvm::sort(BState.Initializers);
661 if (auto Err =
662 runBootstrapSubsectionInitializers(BState, ".CRT$XIA", ".CRT$XIZ"))
663 return Err;
664
665 if (auto Err = runSymbolIfExists(*BState.JD, "__run_after_c_init"))
666 return Err;
667
668 if (auto Err =
669 runBootstrapSubsectionInitializers(BState, ".CRT$XCA", ".CRT$XCZ"))
670 return Err;
671 return Error::success();
672}
673
674Error COFFPlatform::runBootstrapSubsectionInitializers(JDBootstrapState &BState,
675 StringRef Start,
676 StringRef End) {
677 for (auto &Initializer : BState.Initializers)
678 if (Initializer.first >= Start && Initializer.first <= End &&
679 Initializer.second) {
680 auto Res =
681 ES.getExecutorProcessControl().runAsVoidFunction(Initializer.second);
682 if (!Res)
683 return Res.takeError();
684 }
685 return Error::success();
686}
687
688Error COFFPlatform::bootstrapCOFFRuntime(JITDylib &PlatformJD) {
689 // Lookup of runtime symbols causes the collection of initializers if
690 // it's static linking setting.
691 if (auto Err = lookupAndRecordAddrs(
693 {
694 {ES.intern("__orc_rt_coff_platform_bootstrap"),
695 &orc_rt_coff_platform_bootstrap},
696 {ES.intern("__orc_rt_coff_platform_shutdown"),
697 &orc_rt_coff_platform_shutdown},
698 {ES.intern("__orc_rt_coff_register_jitdylib"),
699 &orc_rt_coff_register_jitdylib},
700 {ES.intern("__orc_rt_coff_deregister_jitdylib"),
701 &orc_rt_coff_deregister_jitdylib},
702 {ES.intern("__orc_rt_coff_register_object_sections"),
703 &orc_rt_coff_register_object_sections},
704 {ES.intern("__orc_rt_coff_deregister_object_sections"),
705 &orc_rt_coff_deregister_object_sections},
706 }))
707 return Err;
708
709 // Call bootstrap functions
710 if (auto Err = ES.callSPSWrapper<void()>(orc_rt_coff_platform_bootstrap))
711 return Err;
712
713 // Do the pending jitdylib registration actions that we couldn't do
714 // because orc runtime was not linked fully.
715 for (auto KV : JDBootstrapStates) {
716 auto &JDBState = KV.second;
717 if (auto Err = ES.callSPSWrapper<void(SPSString, SPSExecutorAddr)>(
718 orc_rt_coff_register_jitdylib, JDBState.JDName,
719 JDBState.HeaderAddr))
720 return Err;
721
722 for (auto &ObjSectionMap : JDBState.ObjectSectionsMaps)
723 if (auto Err = ES.callSPSWrapper<void(SPSExecutorAddr,
725 orc_rt_coff_register_object_sections, JDBState.HeaderAddr,
726 ObjSectionMap, false))
727 return Err;
728 }
729
730 // Run static initializers collected in bootstrap stage.
731 for (auto KV : JDBootstrapStates) {
732 auto &JDBState = KV.second;
733 if (auto Err = runBootstrapInitializers(JDBState))
734 return Err;
735 }
736
737 return Error::success();
738}
739
740Error COFFPlatform::runSymbolIfExists(JITDylib &PlatformJD,
741 StringRef SymbolName) {
742 ExecutorAddr jit_function;
743 auto AfterCLookupErr = lookupAndRecordAddrs(
745 {{ES.intern(SymbolName), &jit_function}});
746 if (!AfterCLookupErr) {
747 auto Res = ES.getExecutorProcessControl().runAsVoidFunction(jit_function);
748 if (!Res)
749 return Res.takeError();
750 return Error::success();
751 }
752 if (!AfterCLookupErr.isA<SymbolsNotFound>())
753 return AfterCLookupErr;
754 consumeError(std::move(AfterCLookupErr));
755 return Error::success();
756}
757
758void COFFPlatform::COFFPlatformPlugin::modifyPassConfig(
761
762 bool IsBootstrapping = CP.Bootstrapping.load();
763
764 if (auto InitSymbol = MR.getInitializerSymbol()) {
765 if (InitSymbol == CP.COFFHeaderStartSymbol) {
766 Config.PostAllocationPasses.push_back(
767 [this, &MR, IsBootstrapping](jitlink::LinkGraph &G) {
768 return associateJITDylibHeaderSymbol(G, MR, IsBootstrapping);
769 });
770 return;
771 }
772 Config.PrePrunePasses.push_back([this, &MR](jitlink::LinkGraph &G) {
773 return preserveInitializerSections(G, MR);
774 });
775 }
776
777 if (!IsBootstrapping)
778 Config.PostFixupPasses.push_back(
779 [this, &JD = MR.getTargetJITDylib()](jitlink::LinkGraph &G) {
780 return registerObjectPlatformSections(G, JD);
781 });
782 else
783 Config.PostFixupPasses.push_back(
784 [this, &JD = MR.getTargetJITDylib()](jitlink::LinkGraph &G) {
785 return registerObjectPlatformSectionsInBootstrap(G, JD);
786 });
787}
788
790COFFPlatform::COFFPlatformPlugin::getSyntheticSymbolDependencies(
792 std::lock_guard<std::mutex> Lock(PluginMutex);
793 auto I = InitSymbolDeps.find(&MR);
794 if (I != InitSymbolDeps.end()) {
795 SyntheticSymbolDependenciesMap Result;
796 Result[MR.getInitializerSymbol()] = std::move(I->second);
797 InitSymbolDeps.erase(&MR);
798 return Result;
799 }
800 return SyntheticSymbolDependenciesMap();
801}
802
803Error COFFPlatform::COFFPlatformPlugin::associateJITDylibHeaderSymbol(
805 bool IsBootstraping) {
806 auto I = llvm::find_if(G.defined_symbols(), [this](jitlink::Symbol *Sym) {
807 return Sym->getName() == *CP.COFFHeaderStartSymbol;
808 });
809 assert(I != G.defined_symbols().end() && "Missing COFF header start symbol");
810
811 auto &JD = MR.getTargetJITDylib();
812 std::lock_guard<std::mutex> Lock(CP.PlatformMutex);
813 auto HeaderAddr = (*I)->getAddress();
814 CP.JITDylibToHeaderAddr[&JD] = HeaderAddr;
815 CP.HeaderAddrToJITDylib[HeaderAddr] = &JD;
816 if (!IsBootstraping) {
817 G.allocActions().push_back(
820 CP.orc_rt_coff_register_jitdylib, JD.getName(), HeaderAddr)),
822 CP.orc_rt_coff_deregister_jitdylib, HeaderAddr))});
823 } else {
824 G.allocActions().push_back(
825 {{},
827 CP.orc_rt_coff_deregister_jitdylib, HeaderAddr))});
828 JDBootstrapState BState;
829 BState.JD = &JD;
830 BState.JDName = JD.getName();
831 BState.HeaderAddr = HeaderAddr;
832 CP.JDBootstrapStates.emplace(&JD, BState);
833 }
834
835 return Error::success();
836}
837
838Error COFFPlatform::COFFPlatformPlugin::registerObjectPlatformSections(
840 COFFObjectSectionsMap ObjSecs;
841 auto HeaderAddr = CP.JITDylibToHeaderAddr[&JD];
842 assert(HeaderAddr && "Must be registered jitdylib");
843 for (auto &S : G.sections()) {
845 if (Range.getSize())
846 ObjSecs.push_back(std::make_pair(S.getName().str(), Range.getRange()));
847 }
848
849 G.allocActions().push_back(
850 {cantFail(WrapperFunctionCall::Create<SPSCOFFRegisterObjectSectionsArgs>(
851 CP.orc_rt_coff_register_object_sections, HeaderAddr, ObjSecs, true)),
852 cantFail(
853 WrapperFunctionCall::Create<SPSCOFFDeregisterObjectSectionsArgs>(
854 CP.orc_rt_coff_deregister_object_sections, HeaderAddr,
855 ObjSecs))});
856
857 return Error::success();
858}
859
860Error COFFPlatform::COFFPlatformPlugin::preserveInitializerSections(
862 JITLinkSymbolSet InitSectionSymbols;
863 for (auto &Sec : G.sections())
864 if (isCOFFInitializerSection(Sec.getName()))
865 for (auto *B : Sec.blocks())
866 if (!B->edges_empty())
867 InitSectionSymbols.insert(
868 &G.addAnonymousSymbol(*B, 0, 0, false, true));
869
870 std::lock_guard<std::mutex> Lock(PluginMutex);
871 InitSymbolDeps[&MR] = InitSectionSymbols;
872 return Error::success();
873}
874
875Error COFFPlatform::COFFPlatformPlugin::
876 registerObjectPlatformSectionsInBootstrap(jitlink::LinkGraph &G,
877 JITDylib &JD) {
878 std::lock_guard<std::mutex> Lock(CP.PlatformMutex);
879 auto HeaderAddr = CP.JITDylibToHeaderAddr[&JD];
880 COFFObjectSectionsMap ObjSecs;
881 for (auto &S : G.sections()) {
883 if (Range.getSize())
884 ObjSecs.push_back(std::make_pair(S.getName().str(), Range.getRange()));
885 }
886
887 G.allocActions().push_back(
888 {{},
889 cantFail(
890 WrapperFunctionCall::Create<SPSCOFFDeregisterObjectSectionsArgs>(
891 CP.orc_rt_coff_deregister_object_sections, HeaderAddr,
892 ObjSecs))});
893
894 auto &BState = CP.JDBootstrapStates[&JD];
895 BState.ObjectSectionsMaps.push_back(std::move(ObjSecs));
896
897 // Collect static initializers
898 for (auto &S : G.sections())
899 if (isCOFFInitializerSection(S.getName()))
900 for (auto *B : S.blocks()) {
901 if (B->edges_empty())
902 continue;
903 for (auto &E : B->edges())
904 BState.Initializers.push_back(std::make_pair(
905 S.getName().str(), E.getTarget().getAddress() + E.getAddend()));
906 }
907
908 return Error::success();
909}
910
911} // End namespace orc.
912} // End namespace llvm.
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
#define offsetof(TYPE, MEMBER)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define LLVM_DEBUG(X)
Definition: Debug.h:101
static RegisterPass< DebugifyModulePass > DM("debugify", "Attach debug info to everything")
bool End
Definition: ELF_riscv.cpp:480
RelaxConfig Config
Definition: ELF_riscv.cpp:506
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define _
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
#define H(x, y, z)
Definition: MD5.cpp:57
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
#define P(N)
if(VerifyEach)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:151
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Helper for Errors used as out-parameters.
Definition: Error.h:1130
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
bool empty() const
Definition: SmallVector.h:94
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
const std::string & str() const
Definition: Triple.h:442
static Expected< std::unique_ptr< Archive > > create(MemoryBufferRef Source)
Definition: Archive.cpp:669
Mediates between COFF initialization and ExecutionSession state.
Definition: COFFPlatform.h:33
Error setupJITDylib(JITDylib &JD) override
This method will be called outside the session lock each time a JITDylib is created (unless it is cre...
static ArrayRef< std::pair< const char *, const char * > > standardRuntimeUtilityAliases()
Returns the array of standard runtime utility aliases for COFF.
Error teardownJITDylib(JITDylib &JD) override
This method will be called outside the session lock each time a JITDylib is removed to allow the Plat...
static SymbolAliasMap standardPlatformAliases(ExecutionSession &ES)
Returns an AliasMap containing the default aliases for the COFFPlatform.
Error notifyAdding(ResourceTracker &RT, const MaterializationUnit &MU) override
This method will be called under the ExecutionSession lock each time a MaterializationUnit is added t...
static ArrayRef< std::pair< const char *, const char * > > requiredCXXAliases()
Returns the array of required CXX aliases.
static Expected< std::unique_ptr< COFFPlatform > > Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD, std::unique_ptr< MemoryBuffer > OrcRuntimeArchiveBuffer, LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime=false, const char *VCRuntimePath=nullptr, std::optional< SymbolAliasMap > RuntimeAliases=std::nullopt)
Try to create a COFFPlatform instance, adding the ORC runtime to the given JITDylib.
Error notifyRemoving(ResourceTracker &RT) override
This method will be called under the ExecutionSession lock when a ResourceTracker is removed.
static Expected< std::unique_ptr< COFFVCRuntimeBootstrapper > > Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer, const char *RuntimePath=nullptr)
Try to create a COFFVCRuntimeBootstrapper instance.
static std::unique_ptr< DLLImportDefinitionGenerator > Create(ExecutionSession &ES, ObjectLinkingLayer &L)
Creates a DLLImportDefinitionGenerator instance.
An ExecutionSession represents a running JIT program.
Definition: Core.h:1431
ExecutorProcessControl & getExecutorProcessControl()
Get the ExecutorProcessControl object associated with this ExecutionSession.
Definition: Core.h:1471
const Triple & getTargetTriple() const
Return the triple for the executor.
Definition: Core.h:1474
Error callSPSWrapper(ExecutorAddr WrapperFnAddr, WrapperCallArgTs &&...WrapperCallArgs)
Run a wrapper function using SPS to serialize the arguments and deserialize the results.
Definition: Core.h:1685
SymbolStringPtr intern(StringRef SymName)
Add a symbol name to the SymbolStringPool and return a pointer to it.
Definition: Core.h:1485
JITDylib & createBareJITDylib(std::string Name)
Add a new bare JITDylib to this ExecutionSession.
Definition: Core.cpp:1664
static JITDispatchHandlerFunction wrapAsyncWithSPS(HandlerT &&H)
Wrap a handler that takes concrete argument types (and a sender for a concrete return type) to produc...
Definition: Core.h:1699
void lookup(LookupKind K, const JITDylibSearchOrder &SearchOrder, SymbolLookupSet Symbols, SymbolState RequiredState, SymbolsResolvedCallback NotifyComplete, RegisterDependenciesFunction RegisterDependencies)
Search the given JITDylibs for the given symbols.
Definition: Core.cpp:1802
Error registerJITDispatchHandlers(JITDylib &JD, JITDispatchHandlerAssociationMap WFs)
For each tag symbol name, associate the corresponding AsyncHandlerWrapperFunction with the address of...
Definition: Core.cpp:1911
decltype(auto) runSessionLocked(Func &&F)
Run the given lambda with the session mutex locked.
Definition: Core.h:1495
Represents an address in the executor process.
virtual Expected< int32_t > runAsVoidFunction(ExecutorAddr VoidFnAddr)=0
Run function with a int (*)(void) signature.
Represents a JIT'd dynamic library.
Definition: Core.h:989
Error define(std::unique_ptr< MaterializationUnitType > &&MU, ResourceTrackerSP RT=nullptr)
Define all symbols provided by the materialization unit to be part of this JITDylib.
Definition: Core.h:1910
void addToLinkOrder(const JITDylibSearchOrder &NewLinks)
Append the given JITDylibSearchOrder to the link order for this JITDylib (discarding any elements alr...
Definition: Core.cpp:1031
GeneratorT & addGenerator(std::unique_ptr< GeneratorT > DefGenerator)
Adds a definition generator to this JITDylib and returns a referenece to it.
Definition: Core.h:1893
Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and...
Definition: Core.h:555
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization pseudo-symbol, if any.
Definition: Core.h:591
JITDylib & getTargetJITDylib() const
Returns the target JITDylib that these symbols are being materialized into.
Definition: Core.h:577
A MaterializationUnit represents a set of symbol definitions that can be materialized as a group,...
Definition: Core.h:693
virtual StringRef getName() const =0
Return the name of this materialization unit.
virtual void materialize(std::unique_ptr< MaterializationResponsibility > R)=0
Implementations of this method should materialize all symbols in the materialzation unit,...
const SymbolStringPtr & getInitializerSymbol() const
Returns the initialization symbol for this MaterializationUnit (if any).
Definition: Core.h:726
An ObjectLayer implementation built on JITLink.
ObjectLinkingLayer & addPlugin(std::shared_ptr< Plugin > P)
Add a plugin.
Error add(ResourceTrackerSP, std::unique_ptr< jitlink::LinkGraph > G)
Add a LinkGraph to the JITDylib targeted by the given tracker.
API to remove / transfer ownership of JIT resources.
Definition: Core.h:56
JITDylib & getJITDylib() const
Return the JITDylib targeted by this tracker.
Definition: Core.h:71
static Expected< std::unique_ptr< StaticLibraryDefinitionGenerator > > Create(ObjectLayer &L, std::unique_ptr< MemoryBuffer > ArchiveBuffer, std::unique_ptr< object::Archive > Archive, GetObjectFileInterface GetObjFileInterface=GetObjectFileInterface())
Try to create a StaticLibrarySearchGenerator from the given memory buffer and Archive object.
A set of symbols to look up, each associated with a SymbolLookupFlags value.
Definition: Core.h:183
Pointer to a pooled string representing a symbol name.
Used to notify clients when symbols can not be found during a lookup.
Definition: Core.h:461
A utility class for serializing to a blob from a variadic list.
SPS tag type for expecteds, which are either a T or a string representing an error.
static Expected< WrapperFunctionCall > Create(ExecutorAddr FnAddr, const ArgTs &...Args)
Create a WrapperFunctionCall using the given SPS serializer to serialize the arguments.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_FILE_MACHINE_AMD64
Definition: COFF.h:97
@ NUM_DATA_DIRECTORIES
Definition: COFF.h:613
static const char PEMagic[]
Definition: COFF.h:35
constexpr llvm::endianness Endianness
The endianness of all multi-byte encoded values in MessagePack.
Definition: MsgPack.h:24
JITDylibSearchOrder makeJITDylibSearchOrder(ArrayRef< JITDylib * > JDs, JITDylibLookupFlags Flags=JITDylibLookupFlags::MatchExportedSymbolsOnly)
Convenience function for creating a search order from an ArrayRef of JITDylib*, all with the same fla...
Definition: Core.h:166
std::vector< std::pair< JITDylib *, JITDylibLookupFlags > > JITDylibSearchOrder
A list of (JITDylib*, JITDylibLookupFlags) pairs to be used as a search order during symbol lookup.
Definition: Core.h:162
std::unique_ptr< ReExportsMaterializationUnit > symbolAliases(SymbolAliasMap Aliases)
Create a ReExportsMaterializationUnit with the given aliases.
Definition: Core.h:837
std::unique_ptr< AbsoluteSymbolsMaterializationUnit > absoluteSymbols(SymbolMap Symbols)
Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
Definition: Core.h:791
void lookupAndRecordAddrs(unique_function< void(Error)> OnRecorded, ExecutionSession &ES, LookupKind K, const JITDylibSearchOrder &SearchOrder, std::vector< std::pair< SymbolStringPtr, ExecutorAddr * > > Pairs, SymbolLookupFlags LookupFlags=SymbolLookupFlags::RequiredSymbol)
Record addresses of the given symbols in the given ExecutorAddrs.
static void addAliases(ExecutionSession &ES, SymbolAliasMap &Aliases, ArrayRef< std::pair< const char *, const char * > > AL)
Expected< MaterializationUnit::Interface > getObjectFileInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer)
Returns a MaterializationUnit::Interface for the object file contained in the given buffer,...
jitlink::Block & createHeaderBlock(MachOPlatform &MOP, const MachOPlatform::HeaderOptions &Opts, JITDylib &JD, jitlink::LinkGraph &G, jitlink::Section &HeaderSection)
RegisterDependenciesFunction NoDependenciesToRegister
This can be used as the value for a RegisterDependenciesFunction if there are no dependants to regist...
Definition: Core.cpp:37
bool isCOFFInitializerSection(StringRef Name)
@ Ready
Emitted to memory, but waiting on transitive dependencies.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1380
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:98
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1647
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:756
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1849
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1749
endianness
Definition: bit.h:70
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1069
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
The DOS compatible header at the front of all PE/COFF executables.
Definition: COFF.h:53
The 64-bit PE header that follows the COFF header.
Definition: COFF.h:140