1 //===- elfnix_platform.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains code required to load the rest of the ELF-on-*IX runtime.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "elfnix_platform.h"
14 #include "common.h"
15 #include "compiler.h"
16 #include "error.h"
17 #include "wrapper_function_utils.h"
18
19 #include <algorithm>
20 #include <map>
21 #include <mutex>
22 #include <sstream>
23 #include <string_view>
24 #include <unordered_map>
25 #include <vector>
26
27 using namespace __orc_rt;
28 using namespace __orc_rt::elfnix;
29
30 // Declare function tags for functions in the JIT process.
31 ORC_RT_JIT_DISPATCH_TAG(__orc_rt_elfnix_get_initializers_tag)
32 ORC_RT_JIT_DISPATCH_TAG(__orc_rt_elfnix_get_deinitializers_tag)
33 ORC_RT_JIT_DISPATCH_TAG(__orc_rt_elfnix_symbol_lookup_tag)
34
35 // eh-frame registration functions, made available via aliases
36 // installed by the Platform
37 extern "C" void __register_frame(const void *);
38 extern "C" void __deregister_frame(const void *);
39
40 extern "C" void
41 __unw_add_dynamic_eh_frame_section(const void *) ORC_RT_WEAK_IMPORT;
42 extern "C" void
43 __unw_remove_dynamic_eh_frame_section(const void *) ORC_RT_WEAK_IMPORT;
44
45 namespace {
46
validatePointerSectionExtent(const char * SectionName,const ExecutorAddrRange & SE)47 Error validatePointerSectionExtent(const char *SectionName,
48 const ExecutorAddrRange &SE) {
49 if (SE.size() % sizeof(uintptr_t)) {
50 std::ostringstream ErrMsg;
51 ErrMsg << std::hex << "Size of " << SectionName << " 0x"
52 << SE.Start.getValue() << " -- 0x" << SE.End.getValue()
53 << " is not a pointer multiple";
54 return make_error<StringError>(ErrMsg.str());
55 }
56 return Error::success();
57 }
58
runInitArray(const std::vector<ExecutorAddrRange> & InitArraySections,const ELFNixJITDylibInitializers & MOJDIs)59 Error runInitArray(const std::vector<ExecutorAddrRange> &InitArraySections,
60 const ELFNixJITDylibInitializers &MOJDIs) {
61
62 for (const auto &ModInits : InitArraySections) {
63 if (auto Err = validatePointerSectionExtent(".init_array", ModInits))
64 return Err;
65
66 using InitFunc = void (*)();
67 for (auto *Init : ModInits.toSpan<InitFunc>())
68 (*Init)();
69 }
70
71 return Error::success();
72 }
73
74 struct TLSInfoEntry {
75 unsigned long Key = 0;
76 unsigned long DataAddress = 0;
77 };
78
79 struct TLSDescriptor {
80 void (*Resolver)(void *);
81 TLSInfoEntry *InfoEntry;
82 };
83
84 class ELFNixPlatformRuntimeState {
85 private:
86 struct AtExitEntry {
87 void (*Func)(void *);
88 void *Arg;
89 };
90
91 using AtExitsVector = std::vector<AtExitEntry>;
92
93 struct PerJITDylibState {
94 void *Header = nullptr;
95 size_t RefCount = 0;
96 bool AllowReinitialization = false;
97 AtExitsVector AtExits;
98 };
99
100 public:
101 static void initialize(void *DSOHandle);
102 static ELFNixPlatformRuntimeState &get();
103 static void destroy();
104
105 ELFNixPlatformRuntimeState(void *DSOHandle);
106
107 // Delete copy and move constructors.
108 ELFNixPlatformRuntimeState(const ELFNixPlatformRuntimeState &) = delete;
109 ELFNixPlatformRuntimeState &
110 operator=(const ELFNixPlatformRuntimeState &) = delete;
111 ELFNixPlatformRuntimeState(ELFNixPlatformRuntimeState &&) = delete;
112 ELFNixPlatformRuntimeState &operator=(ELFNixPlatformRuntimeState &&) = delete;
113
114 Error registerObjectSections(ELFNixPerObjectSectionsToRegister POSR);
115 Error deregisterObjectSections(ELFNixPerObjectSectionsToRegister POSR);
116
117 const char *dlerror();
118 void *dlopen(std::string_view Name, int Mode);
119 int dlclose(void *DSOHandle);
120 void *dlsym(void *DSOHandle, std::string_view Symbol);
121
122 int registerAtExit(void (*F)(void *), void *Arg, void *DSOHandle);
123 void runAtExits(void *DSOHandle);
124
125 /// Returns the base address of the section containing ThreadData.
126 Expected<std::pair<const char *, size_t>>
127 getThreadDataSectionFor(const char *ThreadData);
128
getPlatformJDDSOHandle()129 void *getPlatformJDDSOHandle() { return PlatformJDDSOHandle; }
130
131 private:
132 PerJITDylibState *getJITDylibStateByHeaderAddr(void *DSOHandle);
133 PerJITDylibState *getJITDylibStateByName(std::string_view Path);
134 PerJITDylibState &
135 getOrCreateJITDylibState(ELFNixJITDylibInitializers &MOJDIs);
136
137 Error registerThreadDataSection(span<const char> ThreadDataSection);
138
139 Expected<ExecutorAddr> lookupSymbolInJITDylib(void *DSOHandle,
140 std::string_view Symbol);
141
142 Expected<ELFNixJITDylibInitializerSequence>
143 getJITDylibInitializersByName(std::string_view Path);
144 Expected<void *> dlopenInitialize(std::string_view Path, int Mode);
145 Error initializeJITDylib(ELFNixJITDylibInitializers &MOJDIs);
146
147 static ELFNixPlatformRuntimeState *MOPS;
148
149 void *PlatformJDDSOHandle;
150
151 // Frame registration functions:
152 void (*registerEHFrameSection)(const void *) = nullptr;
153 void (*deregisterEHFrameSection)(const void *) = nullptr;
154
155 // FIXME: Move to thread-state.
156 std::string DLFcnError;
157
158 std::recursive_mutex JDStatesMutex;
159 std::unordered_map<void *, PerJITDylibState> JDStates;
160 std::unordered_map<std::string, void *> JDNameToHeader;
161
162 std::mutex ThreadDataSectionsMutex;
163 std::map<const char *, size_t> ThreadDataSections;
164 };
165
166 ELFNixPlatformRuntimeState *ELFNixPlatformRuntimeState::MOPS = nullptr;
167
initialize(void * DSOHandle)168 void ELFNixPlatformRuntimeState::initialize(void *DSOHandle) {
169 assert(!MOPS && "ELFNixPlatformRuntimeState should be null");
170 MOPS = new ELFNixPlatformRuntimeState(DSOHandle);
171 }
172
get()173 ELFNixPlatformRuntimeState &ELFNixPlatformRuntimeState::get() {
174 assert(MOPS && "ELFNixPlatformRuntimeState not initialized");
175 return *MOPS;
176 }
177
destroy()178 void ELFNixPlatformRuntimeState::destroy() {
179 assert(MOPS && "ELFNixPlatformRuntimeState not initialized");
180 delete MOPS;
181 }
182
ELFNixPlatformRuntimeState(void * DSOHandle)183 ELFNixPlatformRuntimeState::ELFNixPlatformRuntimeState(void *DSOHandle)
184 : PlatformJDDSOHandle(DSOHandle) {
185 if (__unw_add_dynamic_eh_frame_section &&
186 __unw_remove_dynamic_eh_frame_section) {
187 registerEHFrameSection = __unw_add_dynamic_eh_frame_section;
188 deregisterEHFrameSection = __unw_remove_dynamic_eh_frame_section;
189 } else {
190 registerEHFrameSection = __register_frame;
191 deregisterEHFrameSection = __deregister_frame;
192 }
193 }
194
registerObjectSections(ELFNixPerObjectSectionsToRegister POSR)195 Error ELFNixPlatformRuntimeState::registerObjectSections(
196 ELFNixPerObjectSectionsToRegister POSR) {
197 if (POSR.EHFrameSection.Start)
198 registerEHFrameSection(POSR.EHFrameSection.Start.toPtr<const char *>());
199
200 if (POSR.ThreadDataSection.Start) {
201 if (auto Err = registerThreadDataSection(
202 POSR.ThreadDataSection.toSpan<const char>()))
203 return Err;
204 }
205
206 return Error::success();
207 }
208
deregisterObjectSections(ELFNixPerObjectSectionsToRegister POSR)209 Error ELFNixPlatformRuntimeState::deregisterObjectSections(
210 ELFNixPerObjectSectionsToRegister POSR) {
211 if (POSR.EHFrameSection.Start)
212 deregisterEHFrameSection(POSR.EHFrameSection.Start.toPtr<const char *>());
213
214 return Error::success();
215 }
216
dlerror()217 const char *ELFNixPlatformRuntimeState::dlerror() { return DLFcnError.c_str(); }
218
dlopen(std::string_view Path,int Mode)219 void *ELFNixPlatformRuntimeState::dlopen(std::string_view Path, int Mode) {
220 std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
221
222 // Use fast path if all JITDylibs are already loaded and don't require
223 // re-running initializers.
224 if (auto *JDS = getJITDylibStateByName(Path)) {
225 if (!JDS->AllowReinitialization) {
226 ++JDS->RefCount;
227 return JDS->Header;
228 }
229 }
230
231 auto H = dlopenInitialize(Path, Mode);
232 if (!H) {
233 DLFcnError = toString(H.takeError());
234 return nullptr;
235 }
236
237 return *H;
238 }
239
dlclose(void * DSOHandle)240 int ELFNixPlatformRuntimeState::dlclose(void *DSOHandle) {
241 runAtExits(DSOHandle);
242 return 0;
243 }
244
dlsym(void * DSOHandle,std::string_view Symbol)245 void *ELFNixPlatformRuntimeState::dlsym(void *DSOHandle,
246 std::string_view Symbol) {
247 auto Addr = lookupSymbolInJITDylib(DSOHandle, Symbol);
248 if (!Addr) {
249 DLFcnError = toString(Addr.takeError());
250 return 0;
251 }
252
253 return Addr->toPtr<void *>();
254 }
255
registerAtExit(void (* F)(void *),void * Arg,void * DSOHandle)256 int ELFNixPlatformRuntimeState::registerAtExit(void (*F)(void *), void *Arg,
257 void *DSOHandle) {
258 // FIXME: Handle out-of-memory errors, returning -1 if OOM.
259 std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
260 auto *JDS = getJITDylibStateByHeaderAddr(DSOHandle);
261 assert(JDS && "JITDylib state not initialized");
262 JDS->AtExits.push_back({F, Arg});
263 return 0;
264 }
265
runAtExits(void * DSOHandle)266 void ELFNixPlatformRuntimeState::runAtExits(void *DSOHandle) {
267 // FIXME: Should atexits be allowed to run concurrently with access to
268 // JDState?
269 AtExitsVector V;
270 {
271 std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
272 auto *JDS = getJITDylibStateByHeaderAddr(DSOHandle);
273 assert(JDS && "JITDlybi state not initialized");
274 std::swap(V, JDS->AtExits);
275 }
276
277 while (!V.empty()) {
278 auto &AE = V.back();
279 AE.Func(AE.Arg);
280 V.pop_back();
281 }
282 }
283
284 Expected<std::pair<const char *, size_t>>
getThreadDataSectionFor(const char * ThreadData)285 ELFNixPlatformRuntimeState::getThreadDataSectionFor(const char *ThreadData) {
286 std::lock_guard<std::mutex> Lock(ThreadDataSectionsMutex);
287 auto I = ThreadDataSections.upper_bound(ThreadData);
288 // Check that we have a valid entry conovering this address.
289 if (I == ThreadDataSections.begin())
290 return make_error<StringError>("No thread local data section for key");
291 I = std::prev(I);
292 if (ThreadData >= I->first + I->second)
293 return make_error<StringError>("No thread local data section for key");
294 return *I;
295 }
296
297 ELFNixPlatformRuntimeState::PerJITDylibState *
getJITDylibStateByHeaderAddr(void * DSOHandle)298 ELFNixPlatformRuntimeState::getJITDylibStateByHeaderAddr(void *DSOHandle) {
299 auto I = JDStates.find(DSOHandle);
300 if (I == JDStates.end())
301 return nullptr;
302 return &I->second;
303 }
304
305 ELFNixPlatformRuntimeState::PerJITDylibState *
getJITDylibStateByName(std::string_view Name)306 ELFNixPlatformRuntimeState::getJITDylibStateByName(std::string_view Name) {
307 // FIXME: Avoid creating string copy here.
308 auto I = JDNameToHeader.find(std::string(Name.data(), Name.size()));
309 if (I == JDNameToHeader.end())
310 return nullptr;
311 void *H = I->second;
312 auto J = JDStates.find(H);
313 assert(J != JDStates.end() &&
314 "JITDylib has name map entry but no header map entry");
315 return &J->second;
316 }
317
318 ELFNixPlatformRuntimeState::PerJITDylibState &
getOrCreateJITDylibState(ELFNixJITDylibInitializers & MOJDIs)319 ELFNixPlatformRuntimeState::getOrCreateJITDylibState(
320 ELFNixJITDylibInitializers &MOJDIs) {
321 void *Header = MOJDIs.DSOHandleAddress.toPtr<void *>();
322
323 auto &JDS = JDStates[Header];
324
325 // If this entry hasn't been created yet.
326 if (!JDS.Header) {
327 assert(!JDNameToHeader.count(MOJDIs.Name) &&
328 "JITDylib has header map entry but no name map entry");
329 JDNameToHeader[MOJDIs.Name] = Header;
330 JDS.Header = Header;
331 }
332
333 return JDS;
334 }
335
registerThreadDataSection(span<const char> ThreadDataSection)336 Error ELFNixPlatformRuntimeState::registerThreadDataSection(
337 span<const char> ThreadDataSection) {
338 std::lock_guard<std::mutex> Lock(ThreadDataSectionsMutex);
339 auto I = ThreadDataSections.upper_bound(ThreadDataSection.data());
340 if (I != ThreadDataSections.begin()) {
341 auto J = std::prev(I);
342 if (J->first + J->second > ThreadDataSection.data())
343 return make_error<StringError>("Overlapping .tdata sections");
344 }
345 ThreadDataSections.insert(
346 I, std::make_pair(ThreadDataSection.data(), ThreadDataSection.size()));
347 return Error::success();
348 }
349
350 Expected<ExecutorAddr>
lookupSymbolInJITDylib(void * DSOHandle,std::string_view Sym)351 ELFNixPlatformRuntimeState::lookupSymbolInJITDylib(void *DSOHandle,
352 std::string_view Sym) {
353 Expected<ExecutorAddr> Result((ExecutorAddr()));
354 if (auto Err = WrapperFunction<SPSExpected<SPSExecutorAddr>(
355 SPSExecutorAddr, SPSString)>::call(&__orc_rt_elfnix_symbol_lookup_tag,
356 Result,
357 ExecutorAddr::fromPtr(DSOHandle),
358 Sym))
359 return std::move(Err);
360 return Result;
361 }
362
363 Expected<ELFNixJITDylibInitializerSequence>
getJITDylibInitializersByName(std::string_view Path)364 ELFNixPlatformRuntimeState::getJITDylibInitializersByName(
365 std::string_view Path) {
366 Expected<ELFNixJITDylibInitializerSequence> Result(
367 (ELFNixJITDylibInitializerSequence()));
368 std::string PathStr(Path.data(), Path.size());
369 if (auto Err =
370 WrapperFunction<SPSExpected<SPSELFNixJITDylibInitializerSequence>(
371 SPSString)>::call(&__orc_rt_elfnix_get_initializers_tag, Result,
372 Path))
373 return std::move(Err);
374 return Result;
375 }
376
377 Expected<void *>
dlopenInitialize(std::string_view Path,int Mode)378 ELFNixPlatformRuntimeState::dlopenInitialize(std::string_view Path, int Mode) {
379 // Either our JITDylib wasn't loaded, or it or one of its dependencies allows
380 // reinitialization. We need to call in to the JIT to see if there's any new
381 // work pending.
382 auto InitSeq = getJITDylibInitializersByName(Path);
383 if (!InitSeq)
384 return InitSeq.takeError();
385
386 // Init sequences should be non-empty.
387 if (InitSeq->empty())
388 return make_error<StringError>(
389 "__orc_rt_elfnix_get_initializers returned an "
390 "empty init sequence");
391
392 // Otherwise register and run initializers for each JITDylib.
393 for (auto &MOJDIs : *InitSeq)
394 if (auto Err = initializeJITDylib(MOJDIs))
395 return std::move(Err);
396
397 // Return the header for the last item in the list.
398 auto *JDS = getJITDylibStateByHeaderAddr(
399 InitSeq->back().DSOHandleAddress.toPtr<void *>());
400 assert(JDS && "Missing state entry for JD");
401 return JDS->Header;
402 }
403
getPriority(const std::string & name)404 long getPriority(const std::string &name) {
405 auto pos = name.find_last_not_of("0123456789");
406 if (pos == name.size() - 1)
407 return 65535;
408 else
409 return std::strtol(name.c_str() + pos + 1, nullptr, 10);
410 }
411
initializeJITDylib(ELFNixJITDylibInitializers & MOJDIs)412 Error ELFNixPlatformRuntimeState::initializeJITDylib(
413 ELFNixJITDylibInitializers &MOJDIs) {
414
415 auto &JDS = getOrCreateJITDylibState(MOJDIs);
416 ++JDS.RefCount;
417
418 using SectionList = std::vector<ExecutorAddrRange>;
419 std::sort(MOJDIs.InitSections.begin(), MOJDIs.InitSections.end(),
420 [](const std::pair<std::string, SectionList> &LHS,
421 const std::pair<std::string, SectionList> &RHS) -> bool {
422 return getPriority(LHS.first) < getPriority(RHS.first);
423 });
424 for (auto &Entry : MOJDIs.InitSections)
425 if (auto Err = runInitArray(Entry.second, MOJDIs))
426 return Err;
427
428 return Error::success();
429 }
430 class ELFNixPlatformRuntimeTLVManager {
431 public:
432 void *getInstance(const char *ThreadData);
433
434 private:
435 std::unordered_map<const char *, char *> Instances;
436 std::unordered_map<const char *, std::unique_ptr<char[]>> AllocatedSections;
437 };
438
getInstance(const char * ThreadData)439 void *ELFNixPlatformRuntimeTLVManager::getInstance(const char *ThreadData) {
440 auto I = Instances.find(ThreadData);
441 if (I != Instances.end())
442 return I->second;
443 auto TDS =
444 ELFNixPlatformRuntimeState::get().getThreadDataSectionFor(ThreadData);
445 if (!TDS) {
446 __orc_rt_log_error(toString(TDS.takeError()).c_str());
447 return nullptr;
448 }
449
450 auto &Allocated = AllocatedSections[TDS->first];
451 if (!Allocated) {
452 Allocated = std::make_unique<char[]>(TDS->second);
453 memcpy(Allocated.get(), TDS->first, TDS->second);
454 }
455 size_t ThreadDataDelta = ThreadData - TDS->first;
456 assert(ThreadDataDelta <= TDS->second && "ThreadData outside section bounds");
457
458 char *Instance = Allocated.get() + ThreadDataDelta;
459 Instances[ThreadData] = Instance;
460 return Instance;
461 }
462
destroyELFNixTLVMgr(void * ELFNixTLVMgr)463 void destroyELFNixTLVMgr(void *ELFNixTLVMgr) {
464 delete static_cast<ELFNixPlatformRuntimeTLVManager *>(ELFNixTLVMgr);
465 }
466
467 } // end anonymous namespace
468
469 //------------------------------------------------------------------------------
470 // JIT entry points
471 //------------------------------------------------------------------------------
472
473 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
__orc_rt_elfnix_platform_bootstrap(char * ArgData,size_t ArgSize)474 __orc_rt_elfnix_platform_bootstrap(char *ArgData, size_t ArgSize) {
475 return WrapperFunction<void(uint64_t)>::handle(
476 ArgData, ArgSize,
477 [](uint64_t &DSOHandle) {
478 ELFNixPlatformRuntimeState::initialize(
479 reinterpret_cast<void *>(DSOHandle));
480 })
481 .release();
482 }
483
484 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
__orc_rt_elfnix_platform_shutdown(char * ArgData,size_t ArgSize)485 __orc_rt_elfnix_platform_shutdown(char *ArgData, size_t ArgSize) {
486 ELFNixPlatformRuntimeState::destroy();
487 return WrapperFunctionResult().release();
488 }
489
490 /// Wrapper function for registering metadata on a per-object basis.
491 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
__orc_rt_elfnix_register_object_sections(char * ArgData,size_t ArgSize)492 __orc_rt_elfnix_register_object_sections(char *ArgData, size_t ArgSize) {
493 return WrapperFunction<SPSError(SPSELFNixPerObjectSectionsToRegister)>::
494 handle(ArgData, ArgSize,
495 [](ELFNixPerObjectSectionsToRegister &POSR) {
496 return ELFNixPlatformRuntimeState::get().registerObjectSections(
497 std::move(POSR));
498 })
499 .release();
500 }
501
502 /// Wrapper for releasing per-object metadat.
503 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
__orc_rt_elfnix_deregister_object_sections(char * ArgData,size_t ArgSize)504 __orc_rt_elfnix_deregister_object_sections(char *ArgData, size_t ArgSize) {
505 return WrapperFunction<SPSError(SPSELFNixPerObjectSectionsToRegister)>::
506 handle(ArgData, ArgSize,
507 [](ELFNixPerObjectSectionsToRegister &POSR) {
508 return ELFNixPlatformRuntimeState::get()
509 .deregisterObjectSections(std::move(POSR));
510 })
511 .release();
512 }
513
514 //------------------------------------------------------------------------------
515 // TLV support
516 //------------------------------------------------------------------------------
517
__orc_rt_elfnix_tls_get_addr_impl(TLSInfoEntry * D)518 ORC_RT_INTERFACE void *__orc_rt_elfnix_tls_get_addr_impl(TLSInfoEntry *D) {
519 auto *TLVMgr = static_cast<ELFNixPlatformRuntimeTLVManager *>(
520 pthread_getspecific(D->Key));
521 if (!TLVMgr)
522 TLVMgr = new ELFNixPlatformRuntimeTLVManager();
523 if (pthread_setspecific(D->Key, TLVMgr)) {
524 __orc_rt_log_error("Call to pthread_setspecific failed");
525 return nullptr;
526 }
527
528 return TLVMgr->getInstance(
529 reinterpret_cast<char *>(static_cast<uintptr_t>(D->DataAddress)));
530 }
531
___orc_rt_elfnix_tlsdesc_resolver_impl(TLSDescriptor * D,const char * ThreadPointer)532 ORC_RT_INTERFACE ptrdiff_t ___orc_rt_elfnix_tlsdesc_resolver_impl(
533 TLSDescriptor *D, const char *ThreadPointer) {
534 const char *TLVPtr = reinterpret_cast<const char *>(
535 __orc_rt_elfnix_tls_get_addr_impl(D->InfoEntry));
536 return TLVPtr - ThreadPointer;
537 }
538
539 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
__orc_rt_elfnix_create_pthread_key(char * ArgData,size_t ArgSize)540 __orc_rt_elfnix_create_pthread_key(char *ArgData, size_t ArgSize) {
541 return WrapperFunction<SPSExpected<uint64_t>(void)>::handle(
542 ArgData, ArgSize,
543 []() -> Expected<uint64_t> {
544 pthread_key_t Key;
545 if (int Err = pthread_key_create(&Key, destroyELFNixTLVMgr)) {
546 __orc_rt_log_error("Call to pthread_key_create failed");
547 return make_error<StringError>(strerror(Err));
548 }
549 return static_cast<uint64_t>(Key);
550 })
551 .release();
552 }
553
554 //------------------------------------------------------------------------------
555 // cxa_atexit support
556 //------------------------------------------------------------------------------
557
__orc_rt_elfnix_cxa_atexit(void (* func)(void *),void * arg,void * dso_handle)558 int __orc_rt_elfnix_cxa_atexit(void (*func)(void *), void *arg,
559 void *dso_handle) {
560 return ELFNixPlatformRuntimeState::get().registerAtExit(func, arg,
561 dso_handle);
562 }
563
__orc_rt_elfnix_atexit(void (* func)(void *))564 int __orc_rt_elfnix_atexit(void (*func)(void *)) {
565 auto &PlatformRTState = ELFNixPlatformRuntimeState::get();
566 return ELFNixPlatformRuntimeState::get().registerAtExit(
567 func, NULL, PlatformRTState.getPlatformJDDSOHandle());
568 }
569
__orc_rt_elfnix_cxa_finalize(void * dso_handle)570 void __orc_rt_elfnix_cxa_finalize(void *dso_handle) {
571 ELFNixPlatformRuntimeState::get().runAtExits(dso_handle);
572 }
573
574 //------------------------------------------------------------------------------
575 // JIT'd dlfcn alternatives.
576 //------------------------------------------------------------------------------
577
__orc_rt_elfnix_jit_dlerror()578 const char *__orc_rt_elfnix_jit_dlerror() {
579 return ELFNixPlatformRuntimeState::get().dlerror();
580 }
581
__orc_rt_elfnix_jit_dlopen(const char * path,int mode)582 void *__orc_rt_elfnix_jit_dlopen(const char *path, int mode) {
583 return ELFNixPlatformRuntimeState::get().dlopen(path, mode);
584 }
585
__orc_rt_elfnix_jit_dlclose(void * dso_handle)586 int __orc_rt_elfnix_jit_dlclose(void *dso_handle) {
587 return ELFNixPlatformRuntimeState::get().dlclose(dso_handle);
588 }
589
__orc_rt_elfnix_jit_dlsym(void * dso_handle,const char * symbol)590 void *__orc_rt_elfnix_jit_dlsym(void *dso_handle, const char *symbol) {
591 return ELFNixPlatformRuntimeState::get().dlsym(dso_handle, symbol);
592 }
593
594 //------------------------------------------------------------------------------
595 // ELFNix Run Program
596 //------------------------------------------------------------------------------
597
__orc_rt_elfnix_run_program(const char * JITDylibName,const char * EntrySymbolName,int argc,char * argv[])598 ORC_RT_INTERFACE int64_t __orc_rt_elfnix_run_program(
599 const char *JITDylibName, const char *EntrySymbolName, int argc,
600 char *argv[]) {
601 using MainTy = int (*)(int, char *[]);
602
603 void *H = __orc_rt_elfnix_jit_dlopen(JITDylibName,
604 __orc_rt::elfnix::ORC_RT_RTLD_LAZY);
605 if (!H) {
606 __orc_rt_log_error(__orc_rt_elfnix_jit_dlerror());
607 return -1;
608 }
609
610 auto *Main =
611 reinterpret_cast<MainTy>(__orc_rt_elfnix_jit_dlsym(H, EntrySymbolName));
612
613 if (!Main) {
614 __orc_rt_log_error(__orc_rt_elfnix_jit_dlerror());
615 return -1;
616 }
617
618 int Result = Main(argc, argv);
619
620 if (__orc_rt_elfnix_jit_dlclose(H) == -1)
621 __orc_rt_log_error(__orc_rt_elfnix_jit_dlerror());
622
623 return Result;
624 }
625