compiler-rt/lib/orc/elfnix_platform.cpp

   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 }