[ORC][COFF] Introduce COFFVCRuntimeBootstrapper.

[sunho]

Summary

Introduces COFFVCRuntimeBootstrapper that loads/initialize vc runtime libraries. In COFF, we *must* jit-link vc runtime libraries as COFF relocation types have no proper way to deal with out-of-reach data symbols ragardless of linking mode. (even dynamic version msvcrt.lib have tons of static data symbols that must be jit-linked) This class tries to load vc runtime library files from msvc installations with an option to override the path.

There are some complications when dealing with static version of vc runtimes. First, they need static initializers to be ran that requires COFFPlatform support but orc runtime will not be usable before vc runtimes are fully initialized. (as orc runtime will use msvc stl libraries) COFFPlatform that will be introduced in a following up patch will collect static initializers and run them manually in host before boostrapping itself. So, the user will have to do the following.

1. Create COFFPlatform that addes static initializer collecting passes.
2. LoadVCRuntime
3. InitializeVCRuntime
4. COFFPlatform.bootstrap()

Second, the internal crt initialization function had to be reimplemented in orc side. There are other ways of doing this, but this is the simplest implementation that makes platform fully responsible for static initializer. The complication comes from the fact that crt initialization functions (such as acrt_initialize or dllmain_crt_process_attach) actually run all static initializers by traversing from __xi_a symbol to __xi_z. This requires symbols to be contiguously allocated in sections alphabetically sorted in memory, which is not possible right now and not practical in jit setting. We might ignore emission of __xi_a and __xi_z symbol and allocate them ourselves, but we have to take extra care after orc runtime boostrap has been done -- as that point orc runtime should be the one running the static initializers.

[sunho]

rebase

[sunho]

Add license header.

[sunho]

EPC

[sunho]

Change API

[lhames]

Otherwise LGTM!

llvm/include/llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h

53

ImportedLibraries looks like an out-parameter. Could this method return an Expected<std::vector<std::string>> instead?

(Similarly for loadDynamicVCRuntime below)

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

262–267

We should move these into the ORC runtime, but we can do that in a follow-up patch.

Could you amend the comment to mention that these methods are temporary, and not to be used?

llvm/include/llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h

+//===----- COFFVCRuntimeSupport.h -- VC runtime support in ORC --*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for loading and initializaing vc runtime in Orc.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_COFFCRUNTIMESUPPORT_H
+#define LLVM_EXECUTIONENGINE_ORC_COFFCRUNTIMESUPPORT_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
+
+#include <future>
+#include <memory>
+#include <thread>
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Bootstraps the vc runtime within jitdylibs.
+class COFFVCRuntimeBootstrapper {
+public:
+  /// A function that will be called with the name of dll file that must be
+  /// loaded.
+  using LoadDynamicLibrary =
+      unique_function<Error(JITDylib &JD, StringRef DLLFileName)>;
+
+  /// Try to create a COFFVCRuntimeBootstrapper instance. An optional
+  /// RuntimePath can be given to specify the location of directory that
+  /// contains all vc runtime library files such as ucrt.lib and msvcrt.lib. If
+  /// not path was given, it will try to search the MSVC toolchain and Windows
+  /// SDK installation and use the found library files automatically.
+  ///
+  /// Note that depending on the build setting, a different library
+  /// file must be used. In general, if vc runtime was statically linked to the
+  /// object file that is to be jit-linked, LoadStaticVCRuntime and
+  /// InitializeStaticVCRuntime must be used with libcmt.lib, libucrt.lib,
+  /// libvcruntimelib. If vc runtime was dynamically linked LoadDynamicVCRuntime
+  /// must be used along with msvcrt.lib, ucrt.lib, vcruntime.lib.
+  ///
+  /// More information is on:
+  /// https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features
+  static Expected<std::unique_ptr<COFFVCRuntimeBootstrapper>>
+  Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+         LoadDynamicLibrary LoadDynLibrary, const char *RuntimePath = nullptr);
+
+  /// Adds symbol definitions of static version of msvc runtime libraries.
+  Error loadStaticVCRuntime(JITDylib &JD, bool DebugVersion = false);
+
+  /// Runs the initializer of static version of msvc runtime libraries.
+  /// This must be called before calling any functions requiring c runtime (e.g.
+  /// printf) within the jit session. Note that proper initialization of vc
+  /// runtime requires ability of running static initializers. Cosider setting
+  /// up COFFPlatform.
+  Error initializeStaticVCRuntime(JITDylib &JD);
+
+  /// Adds symbol definitions of dynamic versino of msvc runtie libraries.
+  Error loadDynamicVCRuntime(JITDylib &JD, bool DebugVersion = false);
+
+private:
+  COFFVCRuntimeBootstrapper(ExecutionSession &ES,
+                            ObjectLinkingLayer &ObjLinkingLayer,
+                            LoadDynamicLibrary LoadDynLibrary,
+                            const char *RuntimePath);
+
+  ExecutionSession &ES;
+  ObjectLinkingLayer &ObjLinkingLayer;
+  std::string RuntimePath;
+  LoadDynamicLibrary LoadDynLibrary;
+
+  struct MSVCToolchainPath {
+    SmallString<256> VCToolchainLib;
+    SmallString<256> UCRTSdkLib;
+  };
+
+  static Expected<MSVCToolchainPath> getMSVCToolchainPath();
+  Error lLoadVCRuntime(JITDylib &JD, ArrayRef<StringRef> VCLibs,
+                       ArrayRef<StringRef> UCRTLibs);
+};
+
+} // namespace orc
+} // namespace llvm
+
+#endif

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

public:
   /// symbol is not found then it be assigned a '0' value.
   virtual Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) = 0;
 
   /// Run function with a main-like signature.
   virtual Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
                                       ArrayRef<std::string> Args) = 0;
 
+  /// Run function with a int (*)(void) signature.
+  virtual Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) = 0;
+
+  /// Run function with a int (*)(int) signature.
+  virtual Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr,
+                                             int Arg) = 0;
+
   /// Run a wrapper function in the executor. The given WFRHandler will be
   /// called on the result when it is returned.
   ///
   /// The wrapper function should be callable as:
   ///
   /// \code{.cpp}
   ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
   /// \endcode{.cpp}
lookupSymbols(ArrayRef<LookupRequest> Request) override {
     llvm_unreachable("Unsupported");
   }
 
   Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
                               ArrayRef<std::string> Args) override {
     llvm_unreachable("Unsupported");
   }
 
+  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override {
+    llvm_unreachable("Unsupported");
+  }
+
+  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override {
+    llvm_unreachable("Unsupported");
+  }
+
   void callWrapperAsync(ExecutorAddr WrapperFnAddr,
                         IncomingWFRHandler OnComplete,
                         ArrayRef<char> ArgBuffer) override {
     llvm_unreachable("Unsupported");
   }
 
   Error disconnect() override { return Error::success(); }
 };
public:
   Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
 
   Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) override;
 
   Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
                               ArrayRef<std::string> Args) override;
 
+  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override;
+
+  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override;
+
   void callWrapperAsync(ExecutorAddr WrapperFnAddr,
                         IncomingWFRHandler OnComplete,
                         ArrayRef<char> ArgBuffer) override;
 
   Error disconnect() override;
 
 private:
   void writeUInt8sAsync(ArrayRef<tpctypes::UInt8Write> Ws,

llvm/include/llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h

 extern const char *MemoryWriteUInt32sWrapperName;
 extern const char *MemoryWriteUInt64sWrapperName;
 extern const char *MemoryWriteBuffersWrapperName;
 
 extern const char *RegisterEHFrameSectionWrapperName;
 extern const char *DeregisterEHFrameSectionWrapperName;
 
 extern const char *RunAsMainWrapperName;
+extern const char *RunAsVoidFunctionWrapperName;
+extern const char *RunAsIntFunctionWrapperName;
 
 using SPSSimpleExecutorDylibManagerOpenSignature =
     shared::SPSExpected<uint64_t>(shared::SPSExecutorAddr, shared::SPSString,
                                   uint64_t);
 
 using SPSSimpleExecutorDylibManagerLookupSignature =
     shared::SPSExpected<shared::SPSSequence<shared::SPSExecutorAddr>>(
         shared::SPSExecutorAddr, uint64_t, shared::SPSRemoteSymbolLookupSet);

 using SPSExecutorSharedMemoryMapperServiceDeinitializeSignature =
     shared::SPSError(shared::SPSExecutorAddr,
                      shared::SPSSequence<shared::SPSExecutorAddr>);
 using SPSExecutorSharedMemoryMapperServiceReleaseSignature = shared::SPSError(
     shared::SPSExecutorAddr, shared::SPSSequence<shared::SPSExecutorAddr>);
 
 using SPSRunAsMainSignature = int64_t(shared::SPSExecutorAddr,
                                       shared::SPSSequence<shared::SPSString>);
-
+using SPSRunAsVoidFunctionSignature = int32_t(shared::SPSExecutorAddr);
+using SPSRunAsIntFunctionSignature = int32_t(shared::SPSExecutorAddr, int32_t);
 } // end namespace rt
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_SHARED_ORCRTBRIDGE_H

llvm/include/llvm/ExecutionEngine/Orc/SimpleRemoteEPC.h

public:
   Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
 
   Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) override;
 
   Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,
                               ArrayRef<std::string> Args) override;
 
+  Expected<int32_t> runAsVoidFunction(ExecutorAddr VoidFnAddr) override;
+
+  Expected<int32_t> runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) override;
+
   void callWrapperAsync(ExecutorAddr WrapperFnAddr,
                         IncomingWFRHandler OnComplete,
                         ArrayRef<char> ArgBuffer) override;
 
   Error disconnect() override;
 
   Expected<HandleMessageAction>
   handleMessage(SimpleRemoteEPCOpcode OpC, uint64_t SeqNo, ExecutorAddr TagAddr,
private:
   Error DisconnectErr = Error::success();
 
   std::unique_ptr<SimpleRemoteEPCTransport> T;
   std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
   std::unique_ptr<MemoryAccess> OwnedMemAccess;
 
   std::unique_ptr<EPCGenericDylibManager> DylibMgr;
   ExecutorAddr RunAsMainAddr;
+  ExecutorAddr RunAsVoidFunctionAddr;
+  ExecutorAddr RunAsIntFunctionAddr;
 
   uint64_t NextSeqNo = 0;
   PendingCallWrapperResultsMap PendingCallWrapperResults;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_SIMPLEREMOTEEPC_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h

 /// before the strings in Args as the first argument to the called function.
 ///
 /// It is legal to have an empty argument list and no program name, however
 /// many main functions will expect a name argument at least, and will fail
 /// if none is provided.
 int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
               Optional<StringRef> ProgramName = None);
 
+int runAsVoidFunction(int (*Func)(void));
+int runAsIntFunction(int (*Func)(int), int Arg);
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

 if( CMAKE_HOST_UNIX AND HAVE_LIBRT )
   set(rt_lib rt)
 endif()
 
 add_llvm_component_library(LLVMOrcJIT
+  COFFVCRuntimeSupport.cpp
   CompileOnDemandLayer.cpp
   CompileUtils.cpp
   Core.cpp
   DebugObjectManagerPlugin.cpp
   DebuggerSupportPlugin.cpp
   DebugUtils.cpp
   EPCDynamicLibrarySearchGenerator.cpp
   EPCDebugObjectRegistrar.cpp
add_llvm_component_library(LLVMOrcJIT
 
   LINK_COMPONENTS
   Core
   ExecutionEngine
   JITLink
   Object
   OrcShared
   OrcTargetProcess
+  WindowsDriver
   MC
   MCDisassembler
   Passes
   RuntimeDyld
   Support
   Target
   TransformUtils
   )

llvm/lib/ExecutionEngine/Orc/COFFVCRuntimeSupport.cpp

+//===------- COFFVCRuntimeSupport.cpp - VC runtime support in ORC ---------===//
+//
+// 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/COFFVCRuntimeSupport.h"
+
+#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/LookupAndRecordAddrs.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/WindowsDriver/MSVCPaths.h"
+
+#define DEBUG_TYPE "orc"
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::shared;
+
+Expected<std::unique_ptr<COFFVCRuntimeBootstrapper>>
+COFFVCRuntimeBootstrapper::Create(ExecutionSession &ES,
+                                  ObjectLinkingLayer &ObjLinkingLayer,
+                                  LoadDynamicLibrary LoadDynLibrary,
+                                  const char *RuntimePath) {
+  return std::unique_ptr<COFFVCRuntimeBootstrapper>(
+      new COFFVCRuntimeBootstrapper(ES, ObjLinkingLayer,
+                                    std::move(LoadDynLibrary), RuntimePath));
+}
+
+COFFVCRuntimeBootstrapper::COFFVCRuntimeBootstrapper(
+    ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
+    LoadDynamicLibrary LoadDynLibrary, const char *RuntimePath)
+    : ES(ES), ObjLinkingLayer(ObjLinkingLayer),
+      LoadDynLibrary(std::move(LoadDynLibrary)) {
+  if (RuntimePath)
+    this->RuntimePath = RuntimePath;
+}
+
+Error COFFVCRuntimeBootstrapper::loadStaticVCRuntime(JITDylib &JD,
+                                                     bool DebugVersion) {
+  StringRef VCLibs[] = {"libvcruntime.lib", "libcmt.lib", "libcpmt.lib"};
+  StringRef UCRTLibs[] = {"libucrt.lib"};
+  if (auto Err =
+          lLoadVCRuntime(JD, makeArrayRef(VCLibs), makeArrayRef(UCRTLibs)))
+    return Err;
+
+  return Error::success();
+}
+
+Error COFFVCRuntimeBootstrapper::loadDynamicVCRuntime(JITDylib &JD,
+                                                      bool DebugVersion) {
+  StringRef VCLibs[] = {"vcruntime.lib", "msvcrt.lib", "msvcprt.lib"};
+  StringRef UCRTLibs[] = {"ucrt.lib"};
+  return lLoadVCRuntime(JD, makeArrayRef(VCLibs), makeArrayRef(UCRTLibs));
+}
+
+Error COFFVCRuntimeBootstrapper::lLoadVCRuntime(JITDylib &JD,
+                                                ArrayRef<StringRef> VCLibs,
+                                                ArrayRef<StringRef> UCRTLibs) {
+  MSVCToolchainPath Path;
+  if (!RuntimePath.empty()) {
+    Path.UCRTSdkLib = RuntimePath;
+    Path.VCToolchainLib = RuntimePath;
+  } else {
+    auto ToolchainPath = getMSVCToolchainPath();
+    if (!ToolchainPath)
+      return ToolchainPath.takeError();
+    Path = *ToolchainPath;
+  }
+  LLVM_DEBUG({
+    dbgs() << "Using VC toolchain pathes\n";
+    dbgs() << "  VC toolchain path: " << Path.VCToolchainLib << "\n";
+    dbgs() << "  UCRT path: " << Path.UCRTSdkLib << "\n";
+  });
+
+  std::vector<std::string> ImportedLibraries;
+  auto LoadLibrary = [&](SmallString<256> LibPath, StringRef LibName) -> Error {
+    sys::path::append(LibPath, LibName);
+
+    auto G = StaticLibraryDefinitionGenerator::Load(ObjLinkingLayer,
+                                                    LibPath.c_str());
+    if (!G)
+      return G.takeError();
+
+    for (auto &Lib : (*G)->getImportedDynamicLibraries())
+      ImportedLibraries.push_back(Lib);
+
+    JD.addGenerator(std::move(*G));
+
+    return Error::success();
+  };
+  for (auto &Lib : UCRTLibs)
+    if (auto Err = LoadLibrary(Path.UCRTSdkLib, Lib))
+      return Err;
+
+  for (auto &Lib : VCLibs)
+    if (auto Err = LoadLibrary(Path.VCToolchainLib, Lib))
+      return Err;
+  ImportedLibraries.push_back("ntdll.dll");
+  ImportedLibraries.push_back("Kernel32.dll");
+
+  for (auto &Lib : ImportedLibraries)
+    if (auto Err = LoadDynLibrary(JD, Lib))
+      return Err;
+
+  return Error::success();
+}
+
+Error COFFVCRuntimeBootstrapper::initializeStaticVCRuntime(JITDylib &JD) {
+  ExecutorAddr jit_scrt_initialize, jit_scrt_dllmain_before_initialize_c,
+      jit_scrt_initialize_type_info,
+      jit_scrt_initialize_default_local_stdio_options;
+  if (auto Err = lookupAndRecordAddrs(
+          ES, LookupKind::Static, makeJITDylibSearchOrder(&JD),
+          {{ES.intern("__scrt_initialize_crt"), &jit_scrt_initialize},
+           {ES.intern("__scrt_dllmain_before_initialize_c"),
+            &jit_scrt_dllmain_before_initialize_c},
+           {ES.intern("?__scrt_initialize_type_info@@YAXXZ"),
+            &jit_scrt_initialize_type_info},
+           {ES.intern("__scrt_initialize_default_local_stdio_options"),
+            &jit_scrt_initialize_default_local_stdio_options}}))
+    return Err;
+
+  auto RunVoidInitFunc = [&](ExecutorAddr Addr) -> Error {
+    if (auto Res = ES.getExecutorProcessControl().runAsVoidFunction(Addr))
+      return Error::success();
+    else
+      return Res.takeError();
+  };
+
+  auto R =
+      ES.getExecutorProcessControl().runAsIntFunction(jit_scrt_initialize, 0);
+  if (!R)
+    return R.takeError();
+
+  if (auto Err = RunVoidInitFunc(jit_scrt_dllmain_before_initialize_c))
+    return Err;
+
+  if (auto Err = RunVoidInitFunc(jit_scrt_initialize_type_info))
+    return Err;
+
+  if (auto Err =
+          RunVoidInitFunc(jit_scrt_initialize_default_local_stdio_options))
+    return Err;
+
+  SymbolAliasMap Alias;
+  Alias[ES.intern("__run_after_c_init")] = {
+      ES.intern("__scrt_dllmain_after_initialize_c"), JITSymbolFlags::Exported};
+  if (auto Err = JD.define(symbolAliases(Alias)))
+    return Err;
+
+  return Error::success();
+}
+
+Expected<COFFVCRuntimeBootstrapper::MSVCToolchainPath>
+COFFVCRuntimeBootstrapper::getMSVCToolchainPath() {
+  std::string VCToolChainPath;
+  ToolsetLayout VSLayout;
+  IntrusiveRefCntPtr<vfs::FileSystem> VFS = vfs::getRealFileSystem();
+  if (!findVCToolChainViaCommandLine(*VFS, None, None, None, VCToolChainPath,
+                                     VSLayout) &&
+      !findVCToolChainViaEnvironment(*VFS, VCToolChainPath, VSLayout) &&
+      !findVCToolChainViaSetupConfig(*VFS, VCToolChainPath, VSLayout) &&
+      !findVCToolChainViaRegistry(VCToolChainPath, VSLayout))
+    return make_error<StringError>("Couldn't find msvc toolchain.",
+                                   inconvertibleErrorCode());
+
+  std::string UniversalCRTSdkPath;
+  std::string UCRTVersion;
+  if (!getUniversalCRTSdkDir(*VFS, None, None, None, UniversalCRTSdkPath,
+                             UCRTVersion))
+    return make_error<StringError>("Couldn't find universal sdk.",
+                                   inconvertibleErrorCode());
+
+  MSVCToolchainPath ToolchainPath;
+  SmallString<256> VCToolchainLib(VCToolChainPath);
+  sys::path::append(VCToolchainLib, "lib", "x64");
+  ToolchainPath.VCToolchainLib = VCToolchainLib;
+
+  SmallString<256> UCRTSdkLib(UniversalCRTSdkPath);
+  sys::path::append(UCRTSdkLib, "Lib", UCRTVersion, "ucrt", "x64");
+  ToolchainPath.UCRTSdkLib = UCRTSdkLib;
+  return ToolchainPath;
+}

llvm/lib/ExecutionEngine/Orc/ExecutorProcessControl.cpp

 
 Expected<int32_t>
 SelfExecutorProcessControl::runAsMain(ExecutorAddr MainFnAddr,
                                       ArrayRef<std::string> Args) {
   using MainTy = int (*)(int, char *[]);
   return orc::runAsMain(MainFnAddr.toPtr<MainTy>(), Args);
 }
 
+Expected<int32_t>
+SelfExecutorProcessControl::runAsVoidFunction(ExecutorAddr VoidFnAddr) {
+  using VoidTy = int (*)();
+  return orc::runAsVoidFunction(VoidFnAddr.toPtr<VoidTy>());
+}
+
+Expected<int32_t>
+SelfExecutorProcessControl::runAsIntFunction(ExecutorAddr IntFnAddr, int Arg) {
+  using IntTy = int (*)(int);
+  return orc::runAsIntFunction(IntFnAddr.toPtr<IntTy>(), Arg);
+}
+
 void SelfExecutorProcessControl::callWrapperAsync(ExecutorAddr WrapperFnAddr,
                                                   IncomingWFRHandler SendResult,
                                                   ArrayRef<char> ArgBuffer) {
   using WrapperFnTy =
       shared::CWrapperFunctionResult (*)(const char *Data, size_t Size);
   auto *WrapperFn = WrapperFnAddr.toPtr<WrapperFnTy>();
   SendResult(WrapperFn(ArgBuffer.data(), ArgBuffer.size()));
 }

llvm/lib/ExecutionEngine/Orc/Shared/OrcRTBridge.cpp

const char *MemoryWriteBuffersWrapperName =
     "__llvm_orc_bootstrap_mem_write_buffers_wrapper";
 
 const char *RegisterEHFrameSectionWrapperName =
     "__llvm_orc_bootstrap_register_ehframe_section_wrapper";
 const char *DeregisterEHFrameSectionWrapperName =
     "__llvm_orc_bootstrap_deregister_ehframe_section_wrapper";
 
 const char *RunAsMainWrapperName = "__llvm_orc_bootstrap_run_as_main_wrapper";
+const char *RunAsVoidFunctionWrapperName =
+    "__llvm_orc_bootstrap_run_as_void_function_wrapper";
+const char *RunAsIntFunctionWrapperName =
+    "__llvm_orc_bootstrap_run_as_int_function_wrapper";
 
 } // end namespace rt
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/SimpleRemoteEPC.cpp

Expected<int32_t> SimpleRemoteEPC::runAsMain(ExecutorAddr MainFnAddr,
                                              ArrayRef<std::string> Args) {
   int64_t Result = 0;
   if (auto Err = callSPSWrapper<rt::SPSRunAsMainSignature>(
           RunAsMainAddr, Result, ExecutorAddr(MainFnAddr), Args))
     return std::move(Err);
   return Result;
 }
 
+Expected<int32_t> SimpleRemoteEPC::runAsVoidFunction(ExecutorAddr VoidFnAddr) {
+  int32_t Result = 0;
+  if (auto Err = callSPSWrapper<rt::SPSRunAsVoidFunctionSignature>(
+          RunAsVoidFunctionAddr, Result, ExecutorAddr(VoidFnAddr)))
+    return std::move(Err);
+  return Result;
+}
+
+Expected<int32_t> SimpleRemoteEPC::runAsIntFunction(ExecutorAddr IntFnAddr,
+                                                    int Arg) {
+  int32_t Result = 0;
+  if (auto Err = callSPSWrapper<rt::SPSRunAsIntFunctionSignature>(
+          RunAsIntFunctionAddr, Result, ExecutorAddr(IntFnAddr), Arg))
+    return std::move(Err);
+  return Result;
+}
+
 void SimpleRemoteEPC::callWrapperAsync(ExecutorAddr WrapperFnAddr,
                                        IncomingWFRHandler OnComplete,
                                        ArrayRef<char> ArgBuffer) {
   uint64_t SeqNo;
   {
     std::lock_guard<std::mutex> Lock(SimpleRemoteEPCMutex);
     SeqNo = getNextSeqNo();
     assert(!PendingCallWrapperResults.count(SeqNo) && "SeqNo already in use");
Error SimpleRemoteEPC::setup(Setup S) {
   });
   TargetTriple = Triple(EI->TargetTriple);
   PageSize = EI->PageSize;
   BootstrapSymbols = std::move(EI->BootstrapSymbols);
 
   if (auto Err = getBootstrapSymbols(
           {{JDI.JITDispatchContext, ExecutorSessionObjectName},
            {JDI.JITDispatchFunction, DispatchFnName},
-           {RunAsMainAddr, rt::RunAsMainWrapperName}}))
+           {RunAsMainAddr, rt::RunAsMainWrapperName},
+           {RunAsVoidFunctionAddr, rt::RunAsVoidFunctionWrapperName},
+           {RunAsIntFunctionAddr, rt::RunAsIntFunctionWrapperName}}))
     return Err;
 
   if (auto DM =
           EPCGenericDylibManager::CreateWithDefaultBootstrapSymbols(*this))
     DylibMgr = std::make_unique<EPCGenericDylibManager>(std::move(*DM));
   else
     return DM.takeError();
 

llvm/lib/ExecutionEngine/Orc/TargetProcess/OrcRTBootstrap.cpp

return WrapperFunction<rt::SPSRunAsMainSignature>::handle(
              ArgData, ArgSize,
              [](ExecutorAddr MainAddr,
                 std::vector<std::string> Args) -> int64_t {
                return runAsMain(MainAddr.toPtr<int (*)(int, char *[])>(), Args);
              })
       .release();
 }
 
+static llvm::orc::shared::CWrapperFunctionResult
+runAsVoidFunctionWrapper(const char *ArgData, size_t ArgSize) {
+  return WrapperFunction<rt::SPSRunAsVoidFunctionSignature>::handle(
+             ArgData, ArgSize,
+             [](ExecutorAddr MainAddr) -> int32_t {
+               return runAsVoidFunction(MainAddr.toPtr<int32_t (*)(void)>());
+             })
+      .release();
+}
+
+static llvm::orc::shared::CWrapperFunctionResult
+runAsIntFunctionWrapper(const char *ArgData, size_t ArgSize) {
+  return WrapperFunction<rt::SPSRunAsIntFunctionSignature>::handle(
+             ArgData, ArgSize,
+             [](ExecutorAddr MainAddr, int32_t Arg) -> int32_t {
+               return runAsIntFunction(MainAddr.toPtr<int32_t (*)(int32_t)>(),
+                                       Arg);
+             })
+      .release();
+}
+
 void addTo(StringMap<ExecutorAddr> &M) {
   M[rt::MemoryWriteUInt8sWrapperName] = ExecutorAddr::fromPtr(
       &writeUIntsWrapper<tpctypes::UInt8Write,
                          shared::SPSMemoryAccessUInt8Write>);
   M[rt::MemoryWriteUInt16sWrapperName] = ExecutorAddr::fromPtr(
       &writeUIntsWrapper<tpctypes::UInt16Write,
                          shared::SPSMemoryAccessUInt16Write>);
   M[rt::MemoryWriteUInt32sWrapperName] = ExecutorAddr::fromPtr(
       &writeUIntsWrapper<tpctypes::UInt32Write,
                          shared::SPSMemoryAccessUInt32Write>);
   M[rt::MemoryWriteUInt64sWrapperName] = ExecutorAddr::fromPtr(
       &writeUIntsWrapper<tpctypes::UInt64Write,
                          shared::SPSMemoryAccessUInt64Write>);
   M[rt::MemoryWriteBuffersWrapperName] =
       ExecutorAddr::fromPtr(&writeBuffersWrapper);
   M[rt::RegisterEHFrameSectionWrapperName] =
       ExecutorAddr::fromPtr(&llvm_orc_registerEHFrameSectionWrapper);
   M[rt::DeregisterEHFrameSectionWrapperName] =
       ExecutorAddr::fromPtr(&llvm_orc_deregisterEHFrameSectionWrapper);
   M[rt::RunAsMainWrapperName] = ExecutorAddr::fromPtr(&runAsMainWrapper);
+  M[rt::RunAsVoidFunctionWrapperName] =
+      ExecutorAddr::fromPtr(&runAsVoidFunctionWrapper);
+  M[rt::RunAsIntFunctionWrapperName] =
+      ExecutorAddr::fromPtr(&runAsIntFunctionWrapper);
 }
 
 } // end namespace rt_bootstrap
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.cpp

for (const auto &Arg : Args) {
     ArgVStorage.back()[Arg.size()] = '\0';
     ArgV.push_back(ArgVStorage.back().get());
   }
   ArgV.push_back(nullptr);
 
   return Main(Args.size() + !!ProgramName, ArgV.data());
 }
 
+int runAsVoidFunction(int (*Func)(void)) { return Func(); }
+
+int runAsIntFunction(int (*Func)(int), int Arg) { return Func(Arg); }
+
 } // End namespace orc.
 } // End namespace llvm.