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 
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 
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 
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 
168 void ELFNixPlatformRuntimeState::initialize(void *DSOHandle) {
169   assert(!MOPS && "ELFNixPlatformRuntimeState should be null");
170   MOPS = new ELFNixPlatformRuntimeState(DSOHandle);
171 }
172 
173 ELFNixPlatformRuntimeState &ELFNixPlatformRuntimeState::get() {
174   assert(MOPS && "ELFNixPlatformRuntimeState not initialized");
175   return *MOPS;
176 }
177 
178 void ELFNixPlatformRuntimeState::destroy() {
179   assert(MOPS && "ELFNixPlatformRuntimeState not initialized");
180   delete MOPS;
181 }
182 
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 
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 
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 
217 const char *ELFNixPlatformRuntimeState::dlerror() { return DLFcnError.c_str(); }
218 
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 
240 int ELFNixPlatformRuntimeState::dlclose(void *DSOHandle) {
241   runAtExits(DSOHandle);
242   return 0;
243 }
244 
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 
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 
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>>
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 *
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 *
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 &
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 
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>
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>
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 *>
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 
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 
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 
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 
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
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
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
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
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 
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 
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
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 
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 
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 
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 
578 const char *__orc_rt_elfnix_jit_dlerror() {
579   return ELFNixPlatformRuntimeState::get().dlerror();
580 }
581 
582 void *__orc_rt_elfnix_jit_dlopen(const char *path, int mode) {
583   return ELFNixPlatformRuntimeState::get().dlopen(path, mode);
584 }
585 
586 int __orc_rt_elfnix_jit_dlclose(void *dso_handle) {
587   return ELFNixPlatformRuntimeState::get().dlclose(dso_handle);
588 }
589 
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 
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