[ORC][ORC_RT][COFF] Remove public bootstrap method.

[sunho]

Summary

Removes public bootstrap method that is not really necessary and not consistent with other platform API.

[lhames]

LGTM. Thanks @sunho!

llvm/include/llvm/ExecutionEngine/Orc/COFFPlatform.h

public:
   /// given JITDylib.
   static Expected<std::unique_ptr<COFFPlatform>>
   Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
          JITDylib &PlatformJD, const char *OrcRuntimePath,
          LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime = false,
          const char *VCRuntimePath = nullptr,
          Optional<SymbolAliasMap> RuntimeAliases = None);
 
-  Error bootstrap(JITDylib &PlatformJD);
-
   ExecutionSession &getExecutionSession() const { return ES; }
   ObjectLinkingLayer &getObjectLinkingLayer() const { return ObjLinkingLayer; }
 
   Error setupJITDylib(JITDylib &JD) override;
   Error teardownJITDylib(JITDylib &JD) override;
   Error notifyAdding(ResourceTracker &RT,
                      const MaterializationUnit &MU) override;
   Error notifyRemoving(ResourceTracker &RT) override;

llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h

 };
 
 /// Constructs LLLazyJIT instances.
 class LLLazyJITBuilder
     : public LLLazyJITBuilderState,
       public LLLazyJITBuilderSetters<LLLazyJIT, LLLazyJITBuilder,
                                      LLLazyJITBuilderState> {};
 
+/// Configure the LLJIT instance to use orc runtime support. 
+Error setUpOrcPlatform(LLJIT& J);
+
 /// Configure the LLJIT instance to scrape modules for llvm.global_ctors and
 /// llvm.global_dtors variables and (if present) build initialization and
 /// deinitialization functions. Platform specific initialization configurations
 /// should be preferred where available.
 void setUpGenericLLVMIRPlatform(LLJIT &J);
 
 /// Configure the LLJIT instance to disable platform support explicitly. This is
 /// useful in two cases: for platforms that don't have such requirements and for
 /// platforms, that we have no explicit support yet and that don't work well
 /// with the generic IR platform.
 Error setUpInactivePlatform(LLJIT &J);
 
 } // End namespace orc
 } // End namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LLJIT_H

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

COFFPlatform::COFFPlatform(ExecutionSession &ES,
   PlatformJD.addGenerator(std::move(*OrcRuntimeArchiveGenerator));
 
   // PlatformJD hasn't been set up by the platform yet (since we're creating
   // the platform now), so set it up.
   if (auto E2 = setupJITDylib(PlatformJD)) {
     Err = std::move(E2);
     return;
   }
-}
 
-Error COFFPlatform::bootstrap(JITDylib &PlatformJD) {
-  for (auto &Lib : DylibsToPreload)
-    if (auto Err = LoadDynLibrary(PlatformJD, Lib))
-      return Err;
+  for (auto& Lib : DylibsToPreload)
+      if (auto E2 = LoadDynLibrary(PlatformJD, Lib)) {
+          Err = std::move(E2);
+          return;
+      }
 
   if (StaticVCRuntime)
-    if (auto Err = VCRuntimeBootstrap->initializeStaticVCRuntime(PlatformJD))
-      return Err;
+      if (auto E2 = VCRuntimeBootstrap->initializeStaticVCRuntime(PlatformJD)) {
+          Err = std::move(E2);
+          return;
+      }
 
   // Associate wrapper function tags with JIT-side function implementations.
-  if (auto Err = associateRuntimeSupportFunctions(PlatformJD)) {
-    return Err;
+  if (auto E2 = associateRuntimeSupportFunctions(PlatformJD)) {
+      Err = std::move(E2);
+      return;
   }
 
   // Lookup addresses of runtime functions callable by the platform,
   // call the platform bootstrap function to initialize the platform-state
   // object in the executor.
-  if (auto Err = bootstrapCOFFRuntime(PlatformJD)) {
-    return Err;
+  if (auto E2 = bootstrapCOFFRuntime(PlatformJD)) {
+      Err = std::move(E2);
+      return;
   }
 
   Bootstrapping.store(false);
   JDBootstrapStates.clear();
-
-  return Error::success();
 }
 
 Expected<COFFPlatform::JITDylibDepMap>
 COFFPlatform::buildJDDepMap(JITDylib &JD) {
   return ES.runSessionLocked([&]() -> Expected<JITDylibDepMap> {
     JITDylibDepMap JDDepMap;
 
     SmallVector<JITDylib *, 16> Worklist({&JD});

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

Function *addHelperAndWrapper(Module &M, StringRef WrapperName,
   if (HelperFn->getReturnType()->isVoidTy())
     IB.CreateRetVoid();
   else
     IB.CreateRet(HelperResult);
 
   return WrapperFn;
 }
 
+class ORCPlatformSupport : public LLJIT::PlatformSupport {
+public:
+  ORCPlatformSupport(orc::LLJIT &J) : J(J) {}
+
+  Error initialize(orc::JITDylib &JD) override {
+    using llvm::orc::shared::SPSExecutorAddr;
+    using llvm::orc::shared::SPSString;
+    using SPSDLOpenSig = SPSExecutorAddr(SPSString, int32_t);
+    enum dlopen_mode : int32_t {
+      ORC_RT_RTLD_LAZY = 0x1,
+      ORC_RT_RTLD_NOW = 0x2,
+      ORC_RT_RTLD_LOCAL = 0x4,
+      ORC_RT_RTLD_GLOBAL = 0x8
+    };
+
+    if (auto WrapperAddr = J.lookup("__orc_rt_jit_dlopen_wrapper")) {
+      return J.getExecutionSession().callSPSWrapper<SPSDLOpenSig>(
+          *WrapperAddr, DSOHandles[&JD], JD.getName(),
+          int32_t(ORC_RT_RTLD_LAZY));
+    } else
+      return WrapperAddr.takeError();
+  }
+
+  Error deinitialize(orc::JITDylib &JD) override {
+    using llvm::orc::shared::SPSExecutorAddr;
+    using SPSDLCloseSig = int32_t(SPSExecutorAddr);
+
+    if (auto WrapperAddr = J.lookup("__orc_rt_jit_dlclose_wrapper")) {
+      int32_t result;
+      auto E = J.getExecutionSession().callSPSWrapper<SPSDLCloseSig>(
+          *WrapperAddr, result, DSOHandles[&JD]);
+      if (E)
+        return E;
+      else if (result)
+        return make_error<StringError>("dlclose failed",
+                                       inconvertibleErrorCode());
+      DSOHandles.erase(&JD);
+    } else
+      return WrapperAddr.takeError();
+    return Error::success();
+  }
+
+private:
+  orc::LLJIT &J;
+  DenseMap<orc::JITDylib *, orc::ExecutorAddr> DSOHandles;
+};
+
 class GenericLLVMIRPlatformSupport;
 
 /// orc::Platform component of Generic LLVM IR Platform support.
 /// Just forwards calls to the GenericLLVMIRPlatformSupport class below.
 class GenericLLVMIRPlatform : public Platform {
 public:
   GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
   Error setupJITDylib(JITDylib &JD) override;
return make_error<StringError>(
         "Added modules have incompatible data layouts: " +
             M.getDataLayout().getStringRepresentation() + " (module) vs " +
             DL.getStringRepresentation() + " (jit)",
         inconvertibleErrorCode());
 
   return Error::success();
 }
 
+Error setUpOrcPlatform(LLJIT& J) {
+    LLVM_DEBUG(
+        { dbgs() << "Setting up orc platform support for LLJIT\n"; });
+    J.setPlatformSupport(std::make_unique<ORCPlatformSupport>(J));
+    return Error::success();
+}
+
 void setUpGenericLLVMIRPlatform(LLJIT &J) {
   LLVM_DEBUG(
       { dbgs() << "Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
   J.setPlatformSupport(std::make_unique<GenericLLVMIRPlatformSupport>(J));
 }
 
 Error setUpInactivePlatform(LLJIT &J) {
   LLVM_DEBUG(

llvm/tools/lli/lli.cpp

bool getCacheFilename(const std::string &ModID, std::string &CacheName) {
 
     CacheName = CacheDir + CacheSubdir;
     size_t pos = CacheName.rfind('.');
     CacheName.replace(pos, CacheName.length() - pos, ".o");
     return true;
   }
 };
 
-class ORCPlatformSupport : public orc::LLJIT::PlatformSupport {
-public:
-  ORCPlatformSupport(orc::LLJIT &J) : J(J) {}
-
-  Error initialize(orc::JITDylib &JD) override {
-    using llvm::orc::shared::SPSExecutorAddr;
-    using llvm::orc::shared::SPSString;
-    using SPSDLOpenSig = SPSExecutorAddr(SPSString, int32_t);
-    enum dlopen_mode : int32_t {
-      ORC_RT_RTLD_LAZY = 0x1,
-      ORC_RT_RTLD_NOW = 0x2,
-      ORC_RT_RTLD_LOCAL = 0x4,
-      ORC_RT_RTLD_GLOBAL = 0x8
-    };
-
-    if (auto WrapperAddr = J.lookup("__orc_rt_jit_dlopen_wrapper")) {
-      return J.getExecutionSession().callSPSWrapper<SPSDLOpenSig>(
-          *WrapperAddr, DSOHandles[&JD], JD.getName(),
-          int32_t(ORC_RT_RTLD_LAZY));
-    } else
-      return WrapperAddr.takeError();
-  }
-
-  Error deinitialize(orc::JITDylib &JD) override {
-    using llvm::orc::shared::SPSExecutorAddr;
-    using SPSDLCloseSig = int32_t(SPSExecutorAddr);
-
-    if (auto WrapperAddr = J.lookup("__orc_rt_jit_dlclose_wrapper")) {
-      int32_t result;
-      auto E = J.getExecutionSession().callSPSWrapper<SPSDLCloseSig>(
-          *WrapperAddr, result, DSOHandles[&JD]);
-      if (E)
-        return E;
-      else if (result)
-        return make_error<StringError>("dlclose failed",
-                                       inconvertibleErrorCode());
-      DSOHandles.erase(&JD);
-    } else
-      return WrapperAddr.takeError();
-    return Error::success();
-  }
-
-private:
-  orc::LLJIT &J;
-  DenseMap<orc::JITDylib *, orc::ExecutorAddr> DSOHandles;
-};
-
 // On Mingw and Cygwin, an external symbol named '__main' is called from the
 // generated 'main' function to allow static initialization.  To avoid linking
 // problems with remote targets (because lli's remote target support does not
 // currently handle external linking) we add a secondary module which defines
 // an empty '__main' function.
 static void addCygMingExtraModule(ExecutionEngine &EE, LLVMContext &Context,
                                   StringRef TargetTripleStr) {
   IRBuilder<> Builder(Context);
if (P == LLJITPlatform::DetectHost) {
     if (JITLinker == JITLinkerKind::JITLink && !OrcRuntime.empty() &&
         (TT->isOSBinFormatMachO() || TT->isOSBinFormatELF()))
       P = LLJITPlatform::ORC;
     else
       P = LLJITPlatform::GenericIR;
   }
   switch (P) {
   case LLJITPlatform::ORC:
-    Builder.setPlatformSetUp([](llvm::orc::LLJIT &J) -> llvm::Error {
-      J.setPlatformSupport(std::make_unique<ORCPlatformSupport>(J));
-      return Error::success();
-    });
+    Builder.setPlatformSetUp(orc::setUpOrcPlatform);
     break;
   case LLJITPlatform::GenericIR:
     // Nothing to do: LLJITBuilder will use this by default.
     break;
   case LLJITPlatform::Inactive:
     Builder.setPlatformSetUp(orc::setUpInactivePlatform);
     break;
   default:

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

if (TT.isOSBinFormatMachO() && !OrcRuntime.empty()) {
     auto LoadDynLibrary = [&, this](JITDylib &JD, StringRef DLLName) -> Error {
       if (!DLLName.endswith_insensitive(".dll"))
         return make_error<StringError>("DLLName not ending with .dll",
                                        inconvertibleErrorCode());
       return loadAndLinkDynamicLibrary(JD, DLLName);
     };
 
     if (auto P = COFFPlatform::Create(ES, ObjLayer, *MainJD, OrcRuntime.c_str(),
-                                      std::move(LoadDynLibrary))) {
-      // Set platform early to register jitdylib of dynamic libraries.
-      auto &CP = **P;
+                                      std::move(LoadDynLibrary))) 
       ES.setPlatform(std::move(*P));
-
-      if (auto E2 = CP.bootstrap(*MainJD)) {
-        Err = std::move(E2);
-        return;
-      }
-    } else {
+     else {
       Err = P.takeError();
       return;
     }
   } else if (TT.isOSBinFormatELF()) {
     if (!NoExec)
       ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
           ES, ExitOnErr(EPCEHFrameRegistrar::Create(this->ES))));
     if (DebuggerSupport)