[ORC] Support COFF orc platform in LLJIT.

[sunho]

Summary

Supports COFF orc platform in LLJIT and share some orc platform setup code from lli to general orc codebase.

[sunho]

Fix test failure. Separate out the platform instance setup part in order to load orc runtime when JIT instance is fully configured. (e.g. in-process symbol generator is set up)

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

public:
   using LoadDynamicLibrary =
       unique_function<Error(JITDylib &JD, StringRef DLLFileName)>;
 
   /// Try to create a COFFPlatform instance, adding the ORC runtime to the
   /// 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,
+         LoadDynamicLibrary LoadDynLibrary = nullptr,
+         bool StaticVCRuntime = false, const char *VCRuntimePath = nullptr,
          Optional<SymbolAliasMap> RuntimeAliases = None);
 
   ExecutionSession &getExecutionSession() const { return ES; }
   ObjectLinkingLayer &getObjectLinkingLayer() const { return ObjLinkingLayer; }
 
   Error setupJITDylib(JITDylib &JD) override;
   Error teardownJITDylib(JITDylib &JD) override;
   Error notifyAdding(ResourceTracker &RT,

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);
+/// Loads orc runtime platform instance from orc runtime archive path
+/// and configure LLJIT instance to use orc runtime for platform support
+/// facilities. (i.e. running static initializers) It fails if JITLink is not
+/// enabled or the target platform and architecture of LLJIT instance is not
+/// supported by orc runtime.
+Error setUpOrcPlatform(StringRef OrcRuntimePath, 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

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

private:
   COFFPlatform &CP;
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 namespace orc {
 
+/// Default load dynamic library function that loads dll as
+/// bare jitdylib and add it to link order.
+static Error LoadDynLibraryAsJD(ExecutionSession &ES, JITDylib &JD,
+                                StringRef DLLName) {
+  if (!DLLName.endswith_insensitive(".dll"))
+    return make_error<StringError>("DLLName not ending with .dll",
+                                   inconvertibleErrorCode());
+  auto G = EPCDynamicLibrarySearchGenerator::Load(ES, DLLName.data());
+  if (!G)
+    return G.takeError();
+  auto DynJD = &ES.createBareJITDylib(DLLName.data());
+  DynJD->addGenerator(std::move(*G));
+
+  JD.addToLinkOrder(*DynJD);
+  return llvm::Error::success();
+}
+
 Expected<std::unique_ptr<COFFPlatform>>
 COFFPlatform::Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
                      JITDylib &PlatformJD, const char *OrcRuntimePath,
                      LoadDynamicLibrary LoadDynLibrary, bool StaticVCRuntime,
                      const char *VCRuntimePath,
                      Optional<SymbolAliasMap> RuntimeAliases) {
   auto &EPC = ES.getExecutorProcessControl();
 
if (auto Err = HostFuncJD.define(absoluteSymbols(
              JITSymbolFlags::Exported}},
            {ES.intern("__orc_rt_jit_dispatch_ctx"),
             {EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
              JITSymbolFlags::Exported}}})))
     return std::move(Err);
 
   PlatformJD.addToLinkOrder(HostFuncJD);
 
+  // If not custom LoadDynLibrary is given use default one.
+  if (!LoadDynLibrary)
+    LoadDynLibrary = [ES = &ES](JITDylib &JD, StringRef DLLName) -> Error {
+      return LoadDynLibraryAsJD(*ES, JD, DLLName);
+    };
+
   // Create the instance.
   Error Err = Error::success();
   auto P = std::unique_ptr<COFFPlatform>(new COFFPlatform(
       ES, ObjLinkingLayer, PlatformJD, OrcRuntimePath,
       std::move(LoadDynLibrary), StaticVCRuntime, VCRuntimePath, Err));
   if (Err)
     return std::move(Err);
   return std::move(P);

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

 //===--------- LLJIT.cpp - An ORC-based JIT for compiling LLVM IR ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/COFFPlatform.h"
 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/Shared/OrcError.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/GlobalVariable.h"
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();
+Error setUpOrcPlatform(StringRef OrcRuntimePath, LLJIT &J) {
+  auto &ES = J.getExecutionSession();
+  auto TT = ES.getExecutorProcessControl().getTargetTriple();
+  if (auto *OLL = dyn_cast<ObjectLinkingLayer>(&J.getObjLinkingLayer())) {
+    if (TT.isOSBinFormatMachO()) {
+      if (auto P = llvm::orc::MachOPlatform::Create(
+              ES, *OLL, J.getMainJITDylib(), OrcRuntimePath.data()))
+        ES.setPlatform(std::move(*P));
+      else
+        return P.takeError();
+    } else if (TT.isOSBinFormatELF()) {
+      if (auto P = llvm::orc::ELFNixPlatform::Create(
+              ES, *OLL, J.getMainJITDylib(), OrcRuntimePath.data()))
+        ES.setPlatform(std::move(*P));
+      else
+        return P.takeError();
+    } else if (TT.isOSBinFormatCOFF()) {
+      if (auto P = llvm::orc::COFFPlatform::Create(
+              ES, *OLL, J.getMainJITDylib(), OrcRuntimePath.data()))
+        ES.setPlatform(std::move(*P));
+      else
+        return P.takeError();
+    } else
+      return llvm::make_error<llvm::StringError>(
+          "No orc runtime support available.", llvm::inconvertibleErrorCode());
+  } else
+    return llvm::make_error<llvm::StringError>(
+        "JITLink is required for orc runtime.", llvm::inconvertibleErrorCode());
+
+  LLVM_DEBUG({ dbgs() << "Setting up orc platform support for LLJIT\n"; });
 }
 
 void setUpGenericLLVMIRPlatform(LLJIT &J) {
   LLVM_DEBUG(
       { dbgs() << "Setting up GenericLLVMIRPlatform support for LLJIT\n"; });
   J.setPlatformSupport(std::make_unique<GenericLLVMIRPlatformSupport>(J));
 }
 

llvm/tools/lli/lli.cpp

Builder.setCompileFunctionCreator(
                                                         CacheManager.get());
       });
   }
 
   // Set up LLJIT platform.
   LLJITPlatform P = Platform;
   if (P == LLJITPlatform::DetectHost) {
     if (JITLinker == JITLinkerKind::JITLink && !OrcRuntime.empty() &&
-        (TT->isOSBinFormatMachO() || TT->isOSBinFormatELF()))
+        (TT->isOSBinFormatMachO() || TT->isOSBinFormatELF() ||
+         TT->isOSBinFormatCOFF()))
       P = LLJITPlatform::ORC;
     else
       P = LLJITPlatform::GenericIR;
   }
   switch (P) {
   case LLJITPlatform::ORC:
-    Builder.setPlatformSetUp(orc::setUpOrcPlatform);
+    Builder.setPlatformSetUp(
+        [](llvm::orc::LLJIT &J) { return setUpOrcPlatform(OrcRuntime, J); });
     break;
   case LLJITPlatform::GenericIR:
     // Nothing to do: LLJITBuilder will use this by default.
     break;
   case LLJITPlatform::Inactive:
     Builder.setPlatformSetUp(orc::setUpInactivePlatform);
     break;
   default:
J->getMainJITDylib().addGenerator(
               return Name != MainName;
             })));
 
   if (GenerateBuiltinFunctions.size() > 0)
     J->getMainJITDylib().addGenerator(
         std::make_unique<LLIBuiltinFunctionGenerator>(GenerateBuiltinFunctions,
                                                       Mangle));
 
-  if (P == LLJITPlatform::ORC) {
-    if (auto *OLL = llvm::dyn_cast<llvm::orc::ObjectLinkingLayer>(ObjLayer)) {
-      auto &ES = J->getExecutionSession();
-      if (TT->isOSBinFormatMachO()) {
-        if (auto P = llvm::orc::MachOPlatform::Create(
-                ES, *OLL, J->getMainJITDylib(), OrcRuntime.c_str()))
-          ES.setPlatform(std::move(*P));
-        else
-          ExitOnErr(P.takeError());
-      } else if (TT->isOSBinFormatELF()) {
-        if (auto P = llvm::orc::ELFNixPlatform::Create(
-                ES, *OLL, J->getMainJITDylib(), OrcRuntime.c_str()))
-          ES.setPlatform(std::move(*P));
-        else
-          ExitOnErr(P.takeError());
-      } else {
-        errs() << "No ORC platform support\n";
-        exit(1);
-      }
-    } else {
-      errs() << "ORC platform requires JITLink\n";
-      exit(1);
-    }
-  }
-
   // Regular modules are greedy: They materialize as a whole and trigger
   // materialization for all required symbols recursively. Lazy modules go
   // through partitioning and they replace outgoing calls with reexport stubs
   // that resolve on call-through.
   auto AddModule = [&](orc::JITDylib &JD, orc::ThreadSafeModule M) {
     return UseJITKind == JITKind::OrcLazy ? J->addLazyIRModule(JD, std::move(M))
                                           : J->addIRModule(JD, std::move(M));
   };