compiler-rt/lib/orc/coff_platform.cpp

   1 //===- coff_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 COFF runtime.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #define NOMINMAX
  14 #include <windows.h>
  15
  16 #include "coff_platform.h"
  17
  18 #include "debug.h"
  19 #include "error.h"
  20 #include "jit_dispatch.h"
  21 #include "wrapper_function_utils.h"
  22
  23 #include <array>
  24 #include <list>
  25 #include <map>
  26 #include <mutex>
  27 #include <sstream>
  28 #include <string_view>
  29 #include <vector>
  30
  31 #define DEBUG_TYPE "coff_platform"
  32
  33 using namespace orc_rt;
  34
  35 namespace orc_rt {
  36
  37 using COFFJITDylibDepInfo = std::vector<ExecutorAddr>;
  38 using COFFJITDylibDepInfoMap =
  39     std::unordered_map<ExecutorAddr, COFFJITDylibDepInfo>;
  40
  41 using SPSCOFFObjectSectionsMap =
  42     SPSSequence<SPSTuple<SPSString, SPSExecutorAddrRange>>;
  43
  44 using SPSCOFFJITDylibDepInfo = SPSSequence<SPSExecutorAddr>;
  45
  46 using SPSCOFFJITDylibDepInfoMap =
  47     SPSSequence<SPSTuple<SPSExecutorAddr, SPSCOFFJITDylibDepInfo>>;
  48
  49 } // namespace orc_rt
  50
  51 ORC_RT_JIT_DISPATCH_TAG(__orc_rt_coff_symbol_lookup_tag)
  52 ORC_RT_JIT_DISPATCH_TAG(__orc_rt_coff_push_initializers_tag)
  53
  54 namespace {
  55 class COFFPlatformRuntimeState {
  56 private:
  57   // Ctor/dtor section.
  58   // Manage lists of *tor functions sorted by the last character of subsection
  59   // name.
  60   struct XtorSection {
  61     void Register(char SubsectionChar, span<void (*)(void)> Xtors) {
  62       Subsections[SubsectionChar - 'A'].push_back(Xtors);
  63       SubsectionsNew[SubsectionChar - 'A'].push_back(Xtors);
  64     }
  65
  66     void RegisterNoRun(char SubsectionChar, span<void (*)(void)> Xtors) {
  67       Subsections[SubsectionChar - 'A'].push_back(Xtors);
  68     }
  69
  70     void Reset() { SubsectionsNew = Subsections; }
  71
  72     void RunAllNewAndFlush();
  73
  74   private:
  75     std::array<std::vector<span<void (*)(void)>>, 26> Subsections;
  76     std::array<std::vector<span<void (*)(void)>>, 26> SubsectionsNew;
  77   };
  78
  79   struct JITDylibState {
  80     std::string Name;
  81     void *Header = nullptr;
  82     size_t LinkedAgainstRefCount = 0;
  83     size_t DlRefCount = 0;
  84     std::vector<JITDylibState *> Deps;
  85     std::vector<void (*)(void)> AtExits;
  86     XtorSection CInitSection;    // XIA~XIZ
  87     XtorSection CXXInitSection;  // XCA~XCZ
  88     XtorSection CPreTermSection; // XPA~XPZ
  89     XtorSection CTermSection;    // XTA~XTZ
  90
  91     bool referenced() const {
  92       return LinkedAgainstRefCount != 0 || DlRefCount != 0;
  93     }
  94   };
  95
  96 public:
  97   static void initialize();
  98   static COFFPlatformRuntimeState &get();
  99   static bool isInitialized() { return CPS; }
 100   static void destroy();
 101
 102   COFFPlatformRuntimeState() = default;
 103
 104   // Delete copy and move constructors.
 105   COFFPlatformRuntimeState(const COFFPlatformRuntimeState &) = delete;
 106   COFFPlatformRuntimeState &
 107   operator=(const COFFPlatformRuntimeState &) = delete;
 108   COFFPlatformRuntimeState(COFFPlatformRuntimeState &&) = delete;
 109   COFFPlatformRuntimeState &operator=(COFFPlatformRuntimeState &&) = delete;
 110
 111   const char *dlerror();
 112   void *dlopen(std::string_view Name, int Mode);
 113   int dlclose(void *Header);
 114   void *dlsym(void *Header, std::string_view Symbol);
 115
 116   Error registerJITDylib(std::string Name, void *Header);
 117   Error deregisterJITDylib(void *Header);
 118
 119   Error registerAtExit(ExecutorAddr HeaderAddr, void (*AtExit)(void));
 120
 121   Error registerObjectSections(
 122       ExecutorAddr HeaderAddr,
 123       std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
 124       bool RunInitializers);
 125   Error deregisterObjectSections(
 126       ExecutorAddr HeaderAddr,
 127       std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs);
 128
 129   void *findJITDylibBaseByPC(uint64_t PC);
 130
 131 private:
 132   Error registerBlockRange(ExecutorAddr HeaderAddr, ExecutorAddrRange Range);
 133   Error deregisterBlockRange(ExecutorAddr HeaderAddr, ExecutorAddrRange Range);
 134
 135   Error registerSEHFrames(ExecutorAddr HeaderAddr,
 136                           ExecutorAddrRange SEHFrameRange);
 137   Error deregisterSEHFrames(ExecutorAddr HeaderAddr,
 138                             ExecutorAddrRange SEHFrameRange);
 139
 140   Expected<void *> dlopenImpl(std::string_view Path, int Mode);
 141   Error dlopenFull(JITDylibState &JDS);
 142   Error dlopenInitialize(JITDylibState &JDS, COFFJITDylibDepInfoMap &DepInfo);
 143
 144   Error dlcloseImpl(void *DSOHandle);
 145   Error dlcloseDeinitialize(JITDylibState &JDS);
 146
 147   JITDylibState *getJITDylibStateByHeader(void *DSOHandle);
 148   JITDylibState *getJITDylibStateByName(std::string_view Path);
 149   Expected<ExecutorAddr> lookupSymbolInJITDylib(void *DSOHandle,
 150                                                 std::string_view Symbol);
 151
 152   static COFFPlatformRuntimeState *CPS;
 153
 154   std::recursive_mutex JDStatesMutex;
 155   std::map<void *, JITDylibState> JDStates;
 156   struct BlockRange {
 157     void *Header;
 158     size_t Size;
 159   };
 160   std::map<void *, BlockRange> BlockRanges;
 161   std::unordered_map<std::string_view, void *> JDNameToHeader;
 162   std::string DLFcnError;
 163 };
 164
 165 } // namespace
 166
 167 COFFPlatformRuntimeState *COFFPlatformRuntimeState::CPS = nullptr;
 168
 169 COFFPlatformRuntimeState::JITDylibState *
 170 COFFPlatformRuntimeState::getJITDylibStateByHeader(void *Header) {
 171   auto I = JDStates.find(Header);
 172   if (I == JDStates.end())
 173     return nullptr;
 174   return &I->second;
 175 }
 176
 177 COFFPlatformRuntimeState::JITDylibState *
 178 COFFPlatformRuntimeState::getJITDylibStateByName(std::string_view Name) {
 179   // FIXME: Avoid creating string copy here.
 180   auto I = JDNameToHeader.find(std::string(Name.data(), Name.size()));
 181   if (I == JDNameToHeader.end())
 182     return nullptr;
 183   void *H = I->second;
 184   auto J = JDStates.find(H);
 185   assert(J != JDStates.end() &&
 186          "JITDylib has name map entry but no header map entry");
 187   return &J->second;
 188 }
 189
 190 Error COFFPlatformRuntimeState::registerJITDylib(std::string Name,
 191                                                  void *Header) {
 192   ORC_RT_DEBUG({
 193     printdbg("Registering JITDylib %s: Header = %p\n", Name.c_str(), Header);
 194   });
 195   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 196   if (JDStates.count(Header)) {
 197     std::ostringstream ErrStream;
 198     ErrStream << "Duplicate JITDylib registration for header " << Header
 199               << " (name = " << Name << ")";
 200     return make_error<StringError>(ErrStream.str());
 201   }
 202   if (JDNameToHeader.count(Name)) {
 203     std::ostringstream ErrStream;
 204     ErrStream << "Duplicate JITDylib registration for header " << Header
 205               << " (header = " << Header << ")";
 206     return make_error<StringError>(ErrStream.str());
 207   }
 208
 209   auto &JDS = JDStates[Header];
 210   JDS.Name = std::move(Name);
 211   JDS.Header = Header;
 212   JDNameToHeader[JDS.Name] = Header;
 213   return Error::success();
 214 }
 215
 216 Error COFFPlatformRuntimeState::deregisterJITDylib(void *Header) {
 217   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 218   auto I = JDStates.find(Header);
 219   if (I == JDStates.end()) {
 220     std::ostringstream ErrStream;
 221     ErrStream << "Attempted to deregister unrecognized header " << Header;
 222     return make_error<StringError>(ErrStream.str());
 223   }
 224
 225   // Remove std::string construction once we can use C++20.
 226   auto J = JDNameToHeader.find(
 227       std::string(I->second.Name.data(), I->second.Name.size()));
 228   assert(J != JDNameToHeader.end() &&
 229          "Missing JDNameToHeader entry for JITDylib");
 230
 231   ORC_RT_DEBUG({
 232     printdbg("Deregistering JITDylib %s: Header = %p\n", I->second.Name.c_str(),
 233              Header);
 234   });
 235
 236   JDNameToHeader.erase(J);
 237   JDStates.erase(I);
 238   return Error::success();
 239 }
 240
 241 void COFFPlatformRuntimeState::XtorSection::RunAllNewAndFlush() {
 242   for (auto &Subsection : SubsectionsNew) {
 243     for (auto &XtorGroup : Subsection)
 244       for (auto &Xtor : XtorGroup)
 245         if (Xtor)
 246           Xtor();
 247     Subsection.clear();
 248   }
 249 }
 250
 251 const char *COFFPlatformRuntimeState::dlerror() { return DLFcnError.c_str(); }
 252
 253 void *COFFPlatformRuntimeState::dlopen(std::string_view Path, int Mode) {
 254   ORC_RT_DEBUG({
 255     std::string S(Path.data(), Path.size());
 256     printdbg("COFFPlatform::dlopen(\"%s\")\n", S.c_str());
 257   });
 258   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 259   if (auto H = dlopenImpl(Path, Mode))
 260     return *H;
 261   else {
 262     // FIXME: Make dlerror thread safe.
 263     DLFcnError = toString(H.takeError());
 264     return nullptr;
 265   }
 266 }
 267
 268 int COFFPlatformRuntimeState::dlclose(void *DSOHandle) {
 269   ORC_RT_DEBUG({
 270     auto *JDS = getJITDylibStateByHeader(DSOHandle);
 271     std::string DylibName;
 272     if (JDS) {
 273       std::string S;
 274       printdbg("COFFPlatform::dlclose(%p) (%s)\n", DSOHandle, S.c_str());
 275     } else
 276       printdbg("COFFPlatform::dlclose(%p) (%s)\n", DSOHandle, "invalid handle");
 277   });
 278   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 279   if (auto Err = dlcloseImpl(DSOHandle)) {
 280     // FIXME: Make dlerror thread safe.
 281     DLFcnError = toString(std::move(Err));
 282     return -1;
 283   }
 284   return 0;
 285 }
 286
 287 void *COFFPlatformRuntimeState::dlsym(void *Header, std::string_view Symbol) {
 288   auto Addr = lookupSymbolInJITDylib(Header, Symbol);
 289   if (!Addr) {
 290     return 0;
 291   }
 292
 293   return Addr->toPtr<void *>();
 294 }
 295
 296 Expected<void *> COFFPlatformRuntimeState::dlopenImpl(std::string_view Path,
 297                                                       int Mode) {
 298   // Try to find JITDylib state by name.
 299   auto *JDS = getJITDylibStateByName(Path);
 300
 301   if (!JDS)
 302     return make_error<StringError>("No registered JTIDylib for path " +
 303                                    std::string(Path.data(), Path.size()));
 304
 305   if (auto Err = dlopenFull(*JDS))
 306     return std::move(Err);
 307
 308   // Bump the ref-count on this dylib.
 309   ++JDS->DlRefCount;
 310
 311   // Return the header address.
 312   return JDS->Header;
 313 }
 314
 315 Error COFFPlatformRuntimeState::dlopenFull(JITDylibState &JDS) {
 316   // Call back to the JIT to push the initializers.
 317   Expected<COFFJITDylibDepInfoMap> DepInfoMap((COFFJITDylibDepInfoMap()));
 318   if (auto Err = WrapperFunction<SPSExpected<SPSCOFFJITDylibDepInfoMap>(
 319           SPSExecutorAddr)>::
 320           call(JITDispatch(&__orc_rt_coff_push_initializers_tag), DepInfoMap,
 321                ExecutorAddr::fromPtr(JDS.Header)))
 322     return Err;
 323   if (!DepInfoMap)
 324     return DepInfoMap.takeError();
 325
 326   if (auto Err = dlopenInitialize(JDS, *DepInfoMap))
 327     return Err;
 328
 329   if (!DepInfoMap->empty()) {
 330     ORC_RT_DEBUG({
 331       printdbg("Unrecognized dep-info key headers in dlopen of %s\n",
 332                JDS.Name.c_str());
 333     });
 334     std::ostringstream ErrStream;
 335     ErrStream << "Encountered unrecognized dep-info key headers "
 336                  "while processing dlopen of "
 337               << JDS.Name;
 338     return make_error<StringError>(ErrStream.str());
 339   }
 340
 341   return Error::success();
 342 }
 343
 344 Error COFFPlatformRuntimeState::dlopenInitialize(
 345     JITDylibState &JDS, COFFJITDylibDepInfoMap &DepInfo) {
 346   ORC_RT_DEBUG({
 347     printdbg("COFFPlatformRuntimeState::dlopenInitialize(\"%s\")\n",
 348              JDS.Name.c_str());
 349   });
 350
 351   // Skip visited dependency.
 352   auto I = DepInfo.find(ExecutorAddr::fromPtr(JDS.Header));
 353   if (I == DepInfo.end())
 354     return Error::success();
 355
 356   auto DI = std::move(I->second);
 357   DepInfo.erase(I);
 358
 359   // Run initializers of dependencies in proper order by depth-first traversal
 360   // of dependency graph.
 361   std::vector<JITDylibState *> OldDeps;
 362   std::swap(JDS.Deps, OldDeps);
 363   JDS.Deps.reserve(DI.size());
 364   for (auto DepHeaderAddr : DI) {
 365     auto *DepJDS = getJITDylibStateByHeader(DepHeaderAddr.toPtr<void *>());
 366     if (!DepJDS) {
 367       std::ostringstream ErrStream;
 368       ErrStream << "Encountered unrecognized dep header "
 369                 << DepHeaderAddr.toPtr<void *>() << " while initializing "
 370                 << JDS.Name;
 371       return make_error<StringError>(ErrStream.str());
 372     }
 373     ++DepJDS->LinkedAgainstRefCount;
 374     if (auto Err = dlopenInitialize(*DepJDS, DepInfo))
 375       return Err;
 376   }
 377
 378   // Run static initializers.
 379   JDS.CInitSection.RunAllNewAndFlush();
 380   JDS.CXXInitSection.RunAllNewAndFlush();
 381
 382   // Decrement old deps.
 383   for (auto *DepJDS : OldDeps) {
 384     --DepJDS->LinkedAgainstRefCount;
 385     if (!DepJDS->referenced())
 386       if (auto Err = dlcloseDeinitialize(*DepJDS))
 387         return Err;
 388   }
 389
 390   return Error::success();
 391 }
 392
 393 Error COFFPlatformRuntimeState::dlcloseImpl(void *DSOHandle) {
 394   // Try to find JITDylib state by header.
 395   auto *JDS = getJITDylibStateByHeader(DSOHandle);
 396
 397   if (!JDS) {
 398     std::ostringstream ErrStream;
 399     ErrStream << "No registered JITDylib for " << DSOHandle;
 400     return make_error<StringError>(ErrStream.str());
 401   }
 402
 403   // Bump the ref-count.
 404   --JDS->DlRefCount;
 405
 406   if (!JDS->referenced())
 407     return dlcloseDeinitialize(*JDS);
 408
 409   return Error::success();
 410 }
 411
 412 Error COFFPlatformRuntimeState::dlcloseDeinitialize(JITDylibState &JDS) {
 413   ORC_RT_DEBUG({
 414     printdbg("COFFPlatformRuntimeState::dlcloseDeinitialize(\"%s\")\n",
 415              JDS.Name.c_str());
 416   });
 417
 418   // Run atexits
 419   for (auto AtExit : JDS.AtExits)
 420     AtExit();
 421   JDS.AtExits.clear();
 422
 423   // Run static terminators.
 424   JDS.CPreTermSection.RunAllNewAndFlush();
 425   JDS.CTermSection.RunAllNewAndFlush();
 426
 427   // Queue all xtors as new again.
 428   JDS.CInitSection.Reset();
 429   JDS.CXXInitSection.Reset();
 430   JDS.CPreTermSection.Reset();
 431   JDS.CTermSection.Reset();
 432
 433   // Deinitialize any dependencies.
 434   for (auto *DepJDS : JDS.Deps) {
 435     --DepJDS->LinkedAgainstRefCount;
 436     if (!DepJDS->referenced())
 437       if (auto Err = dlcloseDeinitialize(*DepJDS))
 438         return Err;
 439   }
 440
 441   return Error::success();
 442 }
 443
 444 Expected<ExecutorAddr>
 445 COFFPlatformRuntimeState::lookupSymbolInJITDylib(void *header,
 446                                                  std::string_view Sym) {
 447   Expected<ExecutorAddr> Result((ExecutorAddr()));
 448   if (auto Err = WrapperFunction<SPSExpected<SPSExecutorAddr>(
 449           SPSExecutorAddr,
 450           SPSString)>::call(JITDispatch(&__orc_rt_coff_symbol_lookup_tag),
 451                             Result, ExecutorAddr::fromPtr(header), Sym))
 452     return std::move(Err);
 453   return Result;
 454 }
 455
 456 Error COFFPlatformRuntimeState::registerObjectSections(
 457     ExecutorAddr HeaderAddr,
 458     std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs,
 459     bool RunInitializers) {
 460   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 461   auto I = JDStates.find(HeaderAddr.toPtr<void *>());
 462   if (I == JDStates.end()) {
 463     std::ostringstream ErrStream;
 464     ErrStream << "Unrecognized header " << HeaderAddr.getValue();
 465     return make_error<StringError>(ErrStream.str());
 466   }
 467   auto &JDState = I->second;
 468   for (auto &KV : Secs) {
 469     if (auto Err = registerBlockRange(HeaderAddr, KV.second))
 470       return Err;
 471     if (KV.first.empty())
 472       continue;
 473     char LastChar = KV.first.data()[KV.first.size() - 1];
 474     if (KV.first == ".pdata") {
 475       if (auto Err = registerSEHFrames(HeaderAddr, KV.second))
 476         return Err;
 477     } else if (KV.first >= ".CRT$XIA" && KV.first <= ".CRT$XIZ") {
 478       if (RunInitializers)
 479         JDState.CInitSection.Register(LastChar,
 480                                       KV.second.toSpan<void (*)(void)>());
 481       else
 482         JDState.CInitSection.RegisterNoRun(LastChar,
 483                                            KV.second.toSpan<void (*)(void)>());
 484     } else if (KV.first >= ".CRT$XCA" && KV.first <= ".CRT$XCZ") {
 485       if (RunInitializers)
 486         JDState.CXXInitSection.Register(LastChar,
 487                                         KV.second.toSpan<void (*)(void)>());
 488       else
 489         JDState.CXXInitSection.RegisterNoRun(
 490             LastChar, KV.second.toSpan<void (*)(void)>());
 491     } else if (KV.first >= ".CRT$XPA" && KV.first <= ".CRT$XPZ")
 492       JDState.CPreTermSection.Register(LastChar,
 493                                        KV.second.toSpan<void (*)(void)>());
 494     else if (KV.first >= ".CRT$XTA" && KV.first <= ".CRT$XTZ")
 495       JDState.CTermSection.Register(LastChar,
 496                                     KV.second.toSpan<void (*)(void)>());
 497   }
 498   return Error::success();
 499 }
 500
 501 Error COFFPlatformRuntimeState::deregisterObjectSections(
 502     ExecutorAddr HeaderAddr,
 503     std::vector<std::pair<std::string_view, ExecutorAddrRange>> Secs) {
 504   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 505   auto I = JDStates.find(HeaderAddr.toPtr<void *>());
 506   if (I == JDStates.end()) {
 507     std::ostringstream ErrStream;
 508     ErrStream << "Attempted to deregister unrecognized header "
 509               << HeaderAddr.getValue();
 510     return make_error<StringError>(ErrStream.str());
 511   }
 512   for (auto &KV : Secs) {
 513     if (auto Err = deregisterBlockRange(HeaderAddr, KV.second))
 514       return Err;
 515     if (KV.first == ".pdata")
 516       if (auto Err = deregisterSEHFrames(HeaderAddr, KV.second))
 517         return Err;
 518   }
 519   return Error::success();
 520 }
 521
 522 Error COFFPlatformRuntimeState::registerSEHFrames(
 523     ExecutorAddr HeaderAddr, ExecutorAddrRange SEHFrameRange) {
 524   int N = (SEHFrameRange.End.getValue() - SEHFrameRange.Start.getValue()) /
 525           sizeof(RUNTIME_FUNCTION);
 526   auto Func = SEHFrameRange.Start.toPtr<PRUNTIME_FUNCTION>();
 527   if (!RtlAddFunctionTable(Func, N,
 528                            static_cast<DWORD64>(HeaderAddr.getValue())))
 529     return make_error<StringError>("Failed to register SEH frames");
 530   return Error::success();
 531 }
 532
 533 Error COFFPlatformRuntimeState::deregisterSEHFrames(
 534     ExecutorAddr HeaderAddr, ExecutorAddrRange SEHFrameRange) {
 535   if (!RtlDeleteFunctionTable(SEHFrameRange.Start.toPtr<PRUNTIME_FUNCTION>()))
 536     return make_error<StringError>("Failed to deregister SEH frames");
 537   return Error::success();
 538 }
 539
 540 Error COFFPlatformRuntimeState::registerBlockRange(ExecutorAddr HeaderAddr,
 541                                                    ExecutorAddrRange Range) {
 542   assert(!BlockRanges.count(Range.Start.toPtr<void *>()) &&
 543          "Block range address already registered");
 544   BlockRange B = {HeaderAddr.toPtr<void *>(), Range.size()};
 545   BlockRanges.emplace(Range.Start.toPtr<void *>(), B);
 546   return Error::success();
 547 }
 548
 549 Error COFFPlatformRuntimeState::deregisterBlockRange(ExecutorAddr HeaderAddr,
 550                                                      ExecutorAddrRange Range) {
 551   assert(BlockRanges.count(Range.Start.toPtr<void *>()) &&
 552          "Block range address not registered");
 553   BlockRanges.erase(Range.Start.toPtr<void *>());
 554   return Error::success();
 555 }
 556
 557 Error COFFPlatformRuntimeState::registerAtExit(ExecutorAddr HeaderAddr,
 558                                                void (*AtExit)(void)) {
 559   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 560   auto I = JDStates.find(HeaderAddr.toPtr<void *>());
 561   if (I == JDStates.end()) {
 562     std::ostringstream ErrStream;
 563     ErrStream << "Unrecognized header " << HeaderAddr.getValue();
 564     return make_error<StringError>(ErrStream.str());
 565   }
 566   I->second.AtExits.push_back(AtExit);
 567   return Error::success();
 568 }
 569
 570 void COFFPlatformRuntimeState::initialize() {
 571   assert(!CPS && "COFFPlatformRuntimeState should be null");
 572   CPS = new COFFPlatformRuntimeState();
 573 }
 574
 575 COFFPlatformRuntimeState &COFFPlatformRuntimeState::get() {
 576   assert(CPS && "COFFPlatformRuntimeState not initialized");
 577   return *CPS;
 578 }
 579
 580 void COFFPlatformRuntimeState::destroy() {
 581   assert(CPS && "COFFPlatformRuntimeState not initialized");
 582   delete CPS;
 583 }
 584
 585 void *COFFPlatformRuntimeState::findJITDylibBaseByPC(uint64_t PC) {
 586   std::lock_guard<std::recursive_mutex> Lock(JDStatesMutex);
 587   auto It = BlockRanges.upper_bound(reinterpret_cast<void *>(PC));
 588   if (It == BlockRanges.begin())
 589     return nullptr;
 590   --It;
 591   auto &Range = It->second;
 592   if (PC >= reinterpret_cast<uint64_t>(It->first) + Range.Size)
 593     return nullptr;
 594   return Range.Header;
 595 }
 596
 597 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 598 __orc_rt_coff_platform_bootstrap(char *ArgData, size_t ArgSize) {
 599   COFFPlatformRuntimeState::initialize();
 600   return WrapperFunctionResult().release();
 601 }
 602
 603 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 604 __orc_rt_coff_platform_shutdown(char *ArgData, size_t ArgSize) {
 605   COFFPlatformRuntimeState::destroy();
 606   return WrapperFunctionResult().release();
 607 }
 608
 609 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 610 __orc_rt_coff_register_jitdylib(char *ArgData, size_t ArgSize) {
 611   return WrapperFunction<SPSError(SPSString, SPSExecutorAddr)>::handle(
 612              ArgData, ArgSize,
 613              [](std::string &Name, ExecutorAddr HeaderAddr) {
 614                return COFFPlatformRuntimeState::get().registerJITDylib(
 615                    std::move(Name), HeaderAddr.toPtr<void *>());
 616              })
 617       .release();
 618 }
 619
 620 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 621 __orc_rt_coff_deregister_jitdylib(char *ArgData, size_t ArgSize) {
 622   return WrapperFunction<SPSError(SPSExecutorAddr)>::handle(
 623              ArgData, ArgSize,
 624              [](ExecutorAddr HeaderAddr) {
 625                return COFFPlatformRuntimeState::get().deregisterJITDylib(
 626                    HeaderAddr.toPtr<void *>());
 627              })
 628       .release();
 629 }
 630
 631 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 632 __orc_rt_coff_register_object_sections(char *ArgData, size_t ArgSize) {
 633   return WrapperFunction<SPSError(SPSExecutorAddr, SPSCOFFObjectSectionsMap,
 634                                   bool)>::
 635       handle(ArgData, ArgSize,
 636              [](ExecutorAddr HeaderAddr,
 637                 std::vector<std::pair<std::string_view, ExecutorAddrRange>>
 638                     &Secs,
 639                 bool RunInitializers) {
 640                return COFFPlatformRuntimeState::get().registerObjectSections(
 641                    HeaderAddr, std::move(Secs), RunInitializers);
 642              })
 643           .release();
 644 }
 645
 646 ORC_RT_INTERFACE orc_rt_CWrapperFunctionResult
 647 __orc_rt_coff_deregister_object_sections(char *ArgData, size_t ArgSize) {
 648   return WrapperFunction<SPSError(SPSExecutorAddr, SPSCOFFObjectSectionsMap)>::
 649       handle(ArgData, ArgSize,
 650              [](ExecutorAddr HeaderAddr,
 651                 std::vector<std::pair<std::string_view, ExecutorAddrRange>>
 652                     &Secs) {
 653                return COFFPlatformRuntimeState::get().deregisterObjectSections(
 654                    HeaderAddr, std::move(Secs));
 655              })
 656           .release();
 657 }
 658 //------------------------------------------------------------------------------
 659 //                        JIT'd dlfcn alternatives.
 660 //------------------------------------------------------------------------------
 661
 662 const char *__orc_rt_coff_jit_dlerror() {
 663   return COFFPlatformRuntimeState::get().dlerror();
 664 }
 665
 666 void *__orc_rt_coff_jit_dlopen(const char *path, int mode) {
 667   return COFFPlatformRuntimeState::get().dlopen(path, mode);
 668 }
 669
 670 int __orc_rt_coff_jit_dlclose(void *header) {
 671   return COFFPlatformRuntimeState::get().dlclose(header);
 672 }
 673
 674 void *__orc_rt_coff_jit_dlsym(void *header, const char *symbol) {
 675   return COFFPlatformRuntimeState::get().dlsym(header, symbol);
 676 }
 677
 678 //------------------------------------------------------------------------------
 679 //                        COFF SEH exception support
 680 //------------------------------------------------------------------------------
 681
 682 struct ThrowInfo {
 683   uint32_t attributes;
 684   void *data;
 685 };
 686
 687 ORC_RT_INTERFACE void __stdcall __orc_rt_coff_cxx_throw_exception(
 688     void *pExceptionObject, ThrowInfo *pThrowInfo) {
 689 #ifdef __clang__
 690 #pragma clang diagnostic push
 691 #pragma clang diagnostic ignored "-Wmultichar"
 692 #endif
 693   constexpr uint32_t EH_EXCEPTION_NUMBER = 'msc' | 0xE0000000;
 694 #ifdef __clang__
 695 #pragma clang diagnostic pop
 696 #endif
 697   constexpr uint32_t EH_MAGIC_NUMBER1 = 0x19930520;
 698   auto BaseAddr = COFFPlatformRuntimeState::get().findJITDylibBaseByPC(
 699       reinterpret_cast<uint64_t>(pThrowInfo));
 700   if (!BaseAddr) {
 701     // This is not from JIT'd region.
 702     // FIXME: Use the default implementation like below when alias api is
 703     // capable. _CxxThrowException(pExceptionObject, pThrowInfo);
 704     fprintf(stderr, "Throwing exception from compiled callback into JIT'd "
 705                     "exception handler not supported yet.\n");
 706     abort();
 707     return;
 708   }
 709   const ULONG_PTR parameters[] = {
 710       EH_MAGIC_NUMBER1,
 711       reinterpret_cast<ULONG_PTR>(pExceptionObject),
 712       reinterpret_cast<ULONG_PTR>(pThrowInfo),
 713       reinterpret_cast<ULONG_PTR>(BaseAddr),
 714   };
 715   RaiseException(EH_EXCEPTION_NUMBER, EXCEPTION_NONCONTINUABLE,
 716                  _countof(parameters), parameters);
 717 }
 718
 719 //------------------------------------------------------------------------------
 720 //                             COFF atexits
 721 //------------------------------------------------------------------------------
 722
 723 typedef int (*OnExitFunction)(void);
 724 typedef void (*AtExitFunction)(void);
 725
 726 ORC_RT_INTERFACE OnExitFunction __orc_rt_coff_onexit(void *Header,
 727                                                      OnExitFunction Func) {
 728   if (auto Err = COFFPlatformRuntimeState::get().registerAtExit(
 729           ExecutorAddr::fromPtr(Header), (void (*)(void))Func)) {
 730     consumeError(std::move(Err));
 731     return nullptr;
 732   }
 733   return Func;
 734 }
 735
 736 ORC_RT_INTERFACE int __orc_rt_coff_atexit(void *Header, AtExitFunction Func) {
 737   if (auto Err = COFFPlatformRuntimeState::get().registerAtExit(
 738           ExecutorAddr::fromPtr(Header), (void (*)(void))Func)) {
 739     consumeError(std::move(Err));
 740     return -1;
 741   }
 742   return 0;
 743 }
 744
 745 //------------------------------------------------------------------------------
 746 //                             COFF Run Program
 747 //------------------------------------------------------------------------------
 748
 749 ORC_RT_INTERFACE int64_t __orc_rt_coff_run_program(const char *JITDylibName,
 750                                                    const char *EntrySymbolName,
 751                                                    int argc, char *argv[]) {
 752   using MainTy = int (*)(int, char *[]);
 753
 754   void *H =
 755       __orc_rt_coff_jit_dlopen(JITDylibName, orc_rt::coff::ORC_RT_RTLD_LAZY);
 756   if (!H) {
 757     __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
 758     return -1;
 759   }
 760
 761   auto *Main =
 762       reinterpret_cast<MainTy>(__orc_rt_coff_jit_dlsym(H, EntrySymbolName));
 763
 764   if (!Main) {
 765     __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
 766     return -1;
 767   }
 768
 769   int Result = Main(argc, argv);
 770
 771   if (__orc_rt_coff_jit_dlclose(H) == -1)
 772     __orc_rt_log_error(__orc_rt_coff_jit_dlerror());
 773
 774   return Result;
 775 }