[Orc] At CBindings for LazyRexports

[vchuravy]

Summary

At C bindings and an example for LLJIT with lazy reexports

[lhames]

The new C API functions should include comments noting that they're relatively unstable, and likely to change in coming releases. As you've seen: these APIs are due for a clean-up.

llvm/include/llvm-c/Orc.h

869

This is actually returning a stubs-manager-builder -- a factory that produces stub-manager objects. This is a hangover from OrcV1 and should be replaced with a simpler stub manager object, we just haven't gotten around to it yet.

Sadly, for the sake of consistency, we probably need to rename the type and API to LLVMOrcIndirectStubsManagerBuilderRef and LLVMOrcCreateLocalIndirectStubsManagerBuilder.

877

This should return an LLVMErrorRef and return the LCTM value (on success) via a result argument:

LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
    LLVMOrcLazyCallThroughManagerRef *Result,
    const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
    LLVMOrcJITTargetAddress ErrorHandlerAddr) {
    auto LCTM = createLocalLazyCallThroughManager(
      Triple(TargetTriple), *unwrap(ES), ErrorHandlerAddr);
    if (!LCTM)
      return wrap(LCTM.takeError());
    *Result = wrap(LCTM->release());
    return LLVMErrorSuccess;
}

[lhames]

The patch will also need to be clang-formatted.

llvm/include/llvm-c/Orc.h

869

Oh, I missed that the implementation was actually running the builder and returning an instance, not returning the builder. Scratch this comment -- these APIs are named correctly.

[vchuravy]

Address review comments

[vchuravy]

address review

[vchuravy]

Add comment and clang-format

[lhames]

LGTM. Thanks Valentin!

llvm/examples/OrcV2Examples/CMakeLists.txt

 add_subdirectory(LLJITDumpObjects)
 add_subdirectory(LLJITWithCustomObjectLinkingLayer)
 add_subdirectory(LLJITWithGDBRegistrationListener)
 add_subdirectory(LLJITWithInitializers)
 add_subdirectory(LLJITWithLazyReexports)
 add_subdirectory(LLJITWithObjectCache)
 add_subdirectory(LLJITWithObjectLinkingLayerPlugin)
 add_subdirectory(LLJITWithOptimizingIRTransform)
 add_subdirectory(LLJITWithTargetProcessControl)
 add_subdirectory(LLJITWithThinLTOSummaries)
 add_subdirectory(OrcV2CBindingsAddObjectFile)
 add_subdirectory(OrcV2CBindingsBasicUsage)
 add_subdirectory(OrcV2CBindingsDumpObjects)
 add_subdirectory(OrcV2CBindingsIRTransforms)
 add_subdirectory(OrcV2CBindingsReflectProcessSymbols)
 add_subdirectory(OrcV2CBindingsRemovableCode)
+add_subdirectory(OrcV2CBindingsLazy)
 
 if(CMAKE_HOST_UNIX)
   add_subdirectory(LLJITWithRemoteDebugging)
 endif()

llvm/examples/OrcV2Examples/OrcV2CBindingsLazy/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Core
+  ExecutionEngine
+  IRReader
+  JITLink
+  MC
+  OrcJIT
+  Support
+  Target
+  nativecodegen
+  )
+
+add_llvm_example(OrcV2CBindingsLazy
+  OrcV2CBindingsLazy.c
+  )

llvm/examples/OrcV2Examples/OrcV2CBindingsLazy/OrcV2CBindingsLazy.c

+//===-------- BasicOrcV2CBindings.c - Basic OrcV2 C Bindings Demo ---------===//
+//
+// 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-c/Core.h"
+#include "llvm-c/Error.h"
+#include "llvm-c/IRReader.h"
+#include "llvm-c/Initialization.h"
+#include "llvm-c/LLJIT.h"
+#include "llvm-c/Support.h"
+#include "llvm-c/Target.h"
+
+#include <stdio.h>
+
+int handleError(LLVMErrorRef Err) {
+  char *ErrMsg = LLVMGetErrorMessage(Err);
+  fprintf(stderr, "Error: %s\n", ErrMsg);
+  LLVMDisposeErrorMessage(ErrMsg);
+  return 1;
+}
+
+// Example IR modules.
+//
+// Note that in the conditionally compiled modules, FooMod and BarMod, functions
+// have been given an _body suffix. This is to ensure that their names do not
+// clash with their lazy-reexports.
+// For clients who do not wish to rename function bodies (e.g. because they want
+// to re-use cached objects between static and JIT compiles) techniques exist to
+// avoid renaming. See the lazy-reexports section of the ORCv2 design doc.
+
+const char FooMod[] = "  define i32 @foo_body() { \n"
+                      "  entry:                   \n"
+                      "    ret i32 1              \n"
+                      "  }                        \n";
+
+const char BarMod[] = "  define i32 @bar_body() { \n"
+                      "  entry:                   \n"
+                      "    ret i32 2              \n"
+                      "  }                        \n";
+
+const char MainMod[] =
+    "  define i32 @entry(i32 %argc) {                                 \n"
+    "  entry:                                                         \n"
+    "    %and = and i32 %argc, 1                                      \n"
+    "    %tobool = icmp eq i32 %and, 0                                \n"
+    "    br i1 %tobool, label %if.end, label %if.then                 \n"
+    "                                                                 \n"
+    "  if.then:                                                       \n"
+    "    %call = tail call i32 @foo()                                 \n"
+    "    br label %return                                             \n"
+    "                                                                 \n"
+    "  if.end:                                                        \n"
+    "    %call1 = tail call i32 @bar()                                \n"
+    "    br label %return                                             \n"
+    "                                                                 \n"
+    "  return:                                                        \n"
+    "    %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.end ] \n"
+    "    ret i32 %retval.0                                            \n"
+    "  }                                                              \n"
+    "                                                                 \n"
+    "  declare i32 @foo()                                             \n"
+    "  declare i32 @bar()                                             \n";
+
+LLVMErrorRef parseExampleModule(const char *Source, size_t Len,
+                                const char *Name,
+                                LLVMOrcThreadSafeModuleRef *TSM) {
+  // Create a new ThreadSafeContext and underlying LLVMContext.
+  LLVMOrcThreadSafeContextRef TSCtx = LLVMOrcCreateNewThreadSafeContext();
+
+  // Get a reference to the underlying LLVMContext.
+  LLVMContextRef Ctx = LLVMOrcThreadSafeContextGetContext(TSCtx);
+
+  // Wrap Source in a MemoryBuffer
+  LLVMMemoryBufferRef MB =
+      LLVMCreateMemoryBufferWithMemoryRange(Source, Len, Name, 0);
+
+  // Parse the LLVM module.
+  LLVMModuleRef M;
+  char *ErrMsg;
+  if (LLVMParseIRInContext(Ctx, MB, &M, &ErrMsg)) {
+    return LLVMCreateStringError(ErrMsg);
+    // TODO: LLVMDisposeMessage(ErrMsg);
+  }
+
+  // Our module is now complete. Wrap it and our ThreadSafeContext in a
+  // ThreadSafeModule.
+  *TSM = LLVMOrcCreateNewThreadSafeModule(M, TSCtx);
+
+  // Dispose of our local ThreadSafeContext value. The underlying LLVMContext
+  // will be kept alive by our ThreadSafeModule, TSM.
+  LLVMOrcDisposeThreadSafeContext(TSCtx);
+
+  return LLVMErrorSuccess;
+}
+
+int main(int argc, char *argv[]) {
+
+  int MainResult = 0;
+
+  // Parse command line arguments and initialize LLVM Core.
+  LLVMParseCommandLineOptions(argc, (const char **)argv, "");
+  LLVMInitializeCore(LLVMGetGlobalPassRegistry());
+
+  // Initialize native target codegen and asm printer.
+  LLVMInitializeNativeTarget();
+  LLVMInitializeNativeAsmPrinter();
+
+  // Set up a JIT instance.
+  LLVMOrcLLJITRef J;
+  const char *TargetTriple;
+  {
+    LLVMErrorRef Err;
+    if ((Err = LLVMOrcCreateLLJIT(&J, 0))) {
+      MainResult = handleError(Err);
+      goto llvm_shutdown;
+    }
+    TargetTriple = LLVMOrcLLJITGetTripleString(J);
+  }
+
+  // Add our demo modules to the JIT.
+  {
+    LLVMOrcJITDylibRef MainJD = LLVMOrcLLJITGetMainJITDylib(J);
+    LLVMErrorRef Err;
+
+    LLVMOrcThreadSafeModuleRef FooTSM;
+    if ((Err =
+             parseExampleModule(FooMod, sizeof(FooMod), "foo-mod", &FooTSM))) {
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+
+    if ((Err = LLVMOrcLLJITAddLLVMIRModule(J, MainJD, FooTSM))) {
+      // If adding the ThreadSafeModule fails then we need to clean it up
+      // ourselves. If adding it succeeds the JIT will manage the memory.
+      LLVMOrcDisposeThreadSafeModule(FooTSM);
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+
+    LLVMOrcThreadSafeModuleRef BarTSM;
+    if ((Err =
+             parseExampleModule(BarMod, sizeof(BarMod), "bar-mod", &BarTSM))) {
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+
+    if ((Err = LLVMOrcLLJITAddLLVMIRModule(J, MainJD, BarTSM))) {
+      LLVMOrcDisposeThreadSafeModule(BarTSM);
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+
+    LLVMOrcThreadSafeModuleRef MainTSM;
+    if ((Err = parseExampleModule(MainMod, sizeof(MainMod), "main-mod",
+                                  &MainTSM))) {
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+
+    if ((Err = LLVMOrcLLJITAddLLVMIRModule(J, MainJD, MainTSM))) {
+      LLVMOrcDisposeThreadSafeModule(MainTSM);
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+  }
+
+  // add lazy reexports
+  LLVMOrcIndirectStubsManagerRef ISM =
+      LLVMOrcCreateLocalIndirectStubsManager(TargetTriple);
+
+  LLVMOrcLazyCallThroughManagerRef LCTM;
+  {
+    LLVMErrorRef Err;
+    LLVMOrcExecutionSessionRef ES = LLVMOrcLLJITGetExecutionSession(J);
+    if ((Err = LLVMOrcCreateLocalLazyCallThroughManager(TargetTriple, ES, 0,
+                                                        &LCTM))) {
+      LLVMOrcDisposeIndirectStubsManager(ISM);
+      MainResult = handleError(Err);
+      goto jit_cleanup;
+    }
+  }
+
+  LLVMJITSymbolFlags flag = {
+      LLVMJITSymbolGenericFlagsExported | LLVMJITSymbolGenericFlagsCallable, 0};
+  LLVMOrcCSymbolAliasMapPair ReExports[2] = {
+      {LLVMOrcLLJITMangleAndIntern(J, "foo"),
+       {LLVMOrcLLJITMangleAndIntern(J, "foo_body"), flag}},
+      {LLVMOrcLLJITMangleAndIntern(J, "bar"),
+       {LLVMOrcLLJITMangleAndIntern(J, "bar_body"), flag}},
+  };
+
+  {
+    LLVMOrcJITDylibRef MainJD = LLVMOrcLLJITGetMainJITDylib(J);
+    LLVMOrcMaterializationUnitRef MU =
+        LLVMOrcLazyReexports(LCTM, ISM, MainJD, ReExports, 2);
+    LLVMOrcJITDylibDefine(MainJD, MU);
+  }
+
+  // Look up the address of our demo entry point.
+  LLVMOrcJITTargetAddress EntryAddr;
+  {
+    LLVMErrorRef Err;
+    if ((Err = LLVMOrcLLJITLookup(J, &EntryAddr, "entry"))) {
+      MainResult = handleError(Err);
+      goto cleanup;
+    }
+  }
+
+  // If we made it here then everything succeeded. Execute our JIT'd code.
+  int32_t (*Entry)(int32_t) = (int32_t(*)(int32_t))EntryAddr;
+  int32_t Result = Entry(argc);
+
+  printf("--- Result ---\n");
+  printf("entry(%i) = %i\n", argc, Result);
+
+cleanup : {
+  LLVMOrcDisposeIndirectStubsManager(ISM);
+  LLVMOrcDisposeLazyCallThroughManager(LCTM);
+}
+
+jit_cleanup:
+  // Destroy our JIT instance. This will clean up any memory that the JIT has
+  // taken ownership of. This operation is non-trivial (e.g. it may need to
+  // JIT static destructors) and may also fail. In that case we want to render
+  // the error to stderr, but not overwrite any existing return value.
+  {
+    LLVMErrorRef Err;
+    if ((Err = LLVMOrcDisposeLLJIT(J))) {
+      int NewFailureResult = handleError(Err);
+      if (MainResult == 0)
+        MainResult = NewFailureResult;
+    }
+  }
+
+llvm_shutdown:
+  // Shut down LLVM.
+  LLVMShutdown();
+
+  return MainResult;
+}

llvm/include/llvm-c/Orc.h

 
 /**
  * Represents a list of (SymbolStringPtr, JITEvaluatedSymbol) pairs that can be
  * used to construct a SymbolMap.
  */
 typedef LLVMJITCSymbolMapPair *LLVMOrcCSymbolMapPairs;
 
 /**
+ * Represents a SymbolAliasMapEntry
+ */
+typedef struct {
+  LLVMOrcSymbolStringPoolEntryRef Name;
+  LLVMJITSymbolFlags Flags;
+} LLVMOrcCSymbolAliasMapEntry;
+
+/**
+ * Represents a pair of a symbol name and SymbolAliasMapEntry.
+ */
+typedef struct {
+  LLVMOrcSymbolStringPoolEntryRef Name;
+  LLVMOrcCSymbolAliasMapEntry Entry;
+} LLVMOrcCSymbolAliasMapPair;
+
+/**
+ * Represents a list of (SymbolStringPtr, (SymbolStringPtr, JITSymbolFlags))
+ * pairs that can be used to construct a SymbolFlagsMap.
+ */
+typedef LLVMOrcCSymbolAliasMapPair *LLVMOrcCSymbolAliasMapPairs;
+
+/**
  * Lookup kind. This can be used by definition generators when deciding whether
  * to produce a definition for a requested symbol.
  *
  * This enum should be kept in sync with llvm::orc::LookupKind.
  */
 typedef enum {
   LLVMOrcLookupKindStatic,
   LLVMOrcLookupKindDLSym

  *
  * The transform is allowed to return an error, in which case the ObjInOut
  * buffer should be disposed of and set to null.
  */
 typedef LLVMErrorRef (*LLVMOrcObjectTransformLayerTransformFunction)(
     void *Ctx, LLVMMemoryBufferRef *ObjInOut);
 
 /**
+ * A reference to an orc::IndirectStubsManager instance.
+ */
+typedef struct LLVMOrcOpaqueIndirectStubsManager
+    *LLVMOrcIndirectStubsManagerRef;
+
+/**
+ * A reference to an orc::LazyCallThroughManager instance.
+ */
+typedef struct LLVMOrcOpaqueLazyCallThroughManager
+    *LLVMOrcLazyCallThroughManagerRef;
+
+/**
  * A reference to an orc::DumpObjects object.
  *
  * Can be used to dump object files to disk with unique names. Useful as an
  * ObjectTransformLayer transform.
  */
 typedef struct LLVMOrcOpaqueDumpObjects *LLVMOrcDumpObjectsRef;
 
 /**

  *
  * If a client wishes to reuse elements of the Sym array after this call they
  * must explicitly retain each of the elements for themselves.
  */
 LLVMOrcMaterializationUnitRef
 LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs);
 
 /**
+ * Create a MaterializationUnit to define lazy re-expots. These are callable
+ * entry points that call through to the given symbols.
+ *
+ * This function takes ownership of the CallableAliases array. The Name
+ * fields of the array elements are taken to have been retained for this
+ * function. This allows the following pattern...
+ *
+ *   size_t NumPairs;
+ *   LLVMOrcCSymbolAliasMapPairs CallableAliases;
+ *   -- Build CallableAliases array --
+ *   LLVMOrcMaterializationUnitRef MU =
+ *      LLVMOrcLazyReexports(LCTM, ISM, JD, CallableAliases, NumPairs);
+ *
+ * ... without requiring cleanup of the elements of the CallableAliases array afterwards.
+ *
+ * The client is still responsible for deleting the CallableAliases array itself.
+ *
+ * If a client wishes to reuse elements of the CallableAliases array after this call they
+ * must explicitly retain each of the elements for themselves.
+ */
+LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
+    LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
+    LLVMOrcJITDylibRef SourceRef, LLVMOrcCSymbolAliasMapPairs CallableAliases,
+    size_t NumPairs);
+// TODO: ImplSymbolMad SrcJDLoc
+
+/**
  * Create a "bare" JITDylib.
  *
  * The client is responsible for ensuring that the JITDylib's name is unique,
  * e.g. by calling LLVMOrcExecutionSessionGetJTIDylibByName first.
  *
  * This call does not install any library code or symbols into the newly
  * created JITDylib. The client is responsible for all configuration.
  */

 /**
  * Set the transform function on an LLVMOrcObjectTransformLayer.
  */
 void LLVMOrcObjectTransformLayerSetTransform(
     LLVMOrcObjectTransformLayerRef ObjTransformLayer,
     LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx);
 
 /**
+ * Create a LocalIndirectStubsManager from the given target triple.
+ *
+ * The resulting IndirectStubsManager is owned by the client
+ * and must be disposed of by calling LLVMOrcDisposeDisposeIndirectStubsManager.
+ */
+LLVMOrcIndirectStubsManagerRef
+LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple);
+
+/**
+ * Dispose of an IndirectStubsManager.
+ */
+void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM);
+
+LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
+    const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
+    LLVMOrcJITTargetAddress ErrorHandlerAddr,
+    LLVMOrcLazyCallThroughManagerRef *LCTM);
+
+/**
+ * Dispose of an LazyCallThroughManager.
+ */
+void LLVMOrcDisposeLazyCallThroughManager(
+    LLVMOrcLazyCallThroughManagerRef LCTM);
+
+/**
  * Create a DumpObjects instance.
  *
  * DumpDir specifies the path to write dumped objects to. DumpDir may be empty
  * in which case files will be dumped to the working directory.
  *
  * IdentifierOverride specifies a file name stem to use when dumping objects.
  * If empty then each MemoryBuffer's identifier will be used (with a .o suffix
  * added if not already present). If an identifier override is supplied it will

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeModule, LLVMOrcThreadSafeModuleRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITTargetMachineBuilder,
                                    LLVMOrcJITTargetMachineBuilderRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectLayer, LLVMOrcObjectLayerRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRTransformLayer, LLVMOrcIRTransformLayerRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ObjectTransformLayer,
                                    LLVMOrcObjectTransformLayerRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DumpObjects, LLVMOrcDumpObjectsRef)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IndirectStubsManager,
+                                   LLVMOrcIndirectStubsManagerRef)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LazyCallThroughManager,
+                                   LLVMOrcLazyCallThroughManagerRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJITBuilder, LLVMOrcLLJITBuilderRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLJIT, LLVMOrcLLJITRef)
-
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
 
 namespace llvm {
 namespace orc {
 
 class CAPIDefinitionGenerator final : public DefinitionGenerator {
 public:
   CAPIDefinitionGenerator(
for (size_t I = 0; I != NumPairs; ++I) {
     JITSymbolFlags Flags = toJITSymbolFlags(Syms[I].Sym.Flags);
     SM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
         JITEvaluatedSymbol(Syms[I].Sym.Address, Flags);
   }
 
   return wrap(absoluteSymbols(std::move(SM)).release());
 }
 
+LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
+    LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
+    LLVMOrcJITDylibRef SourceJD, LLVMOrcCSymbolAliasMapPairs CallableAliases,
+    size_t NumPairs) {
+
+  SymbolAliasMap SAM;
+  for (size_t I = 0; I != NumPairs; ++I) {
+    auto pair = CallableAliases[I];
+    JITSymbolFlags Flags = toJITSymbolFlags(pair.Entry.Flags);
+    SymbolStringPtr Name =
+        OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Entry.Name));
+    SAM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(pair.Name))] =
+        SymbolAliasMapEntry(Name, Flags);
+  }
+
+  return wrap(lazyReexports(*unwrap(LCTM), *unwrap(ISM), *unwrap(SourceJD),
+                            std::move(SAM))
+                  .release());
+}
+
 LLVMOrcJITDylibRef
 LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
                                           const char *Name) {
   return wrap(&unwrap(ES)->createBareJITDylib(Name));
 }
 
 LLVMErrorRef
 LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
   assert(Listener && "Listener must not be null");
   reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer))
       ->registerJITEventListener(*unwrap(Listener));
 }
 
 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
   return wrap(&unwrap(J)->getIRTransformLayer());
 }
+
+LLVMOrcIndirectStubsManagerRef
+LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple) {
+  auto builder = createLocalIndirectStubsManagerBuilder(Triple(TargetTriple));
+  return wrap(builder().release());
+}
+
+void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM) {
+  std::unique_ptr<IndirectStubsManager> TmpISM(unwrap(ISM));
+}
+
+LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
+    const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
+    LLVMOrcJITTargetAddress ErrorHandlerAddr,
+    LLVMOrcLazyCallThroughManagerRef *Result) {
+  auto LCTM = createLocalLazyCallThroughManager(Triple(TargetTriple),
+                                                *unwrap(ES), ErrorHandlerAddr);
+
+  if (!LCTM)
+    return wrap(LCTM.takeError());
+  *Result = wrap(LCTM->release());
+  return LLVMErrorSuccess;
+}
+
+void LLVMOrcDisposeLazyCallThroughManager(
+    LLVMOrcLazyCallThroughManagerRef LCM) {
+  std::unique_ptr<LazyCallThroughManager> TmpLCM(unwrap(LCM));
+}

llvm/test/CMakeLists.txt

list(APPEND LLVM_TEST_DEPENDS
     Kaleidoscope-Ch5
     Kaleidoscope-Ch6
     Kaleidoscope-Ch7
     LLJITWithThinLTOSummaries
     OrcV2CBindingsBasicUsage
     OrcV2CBindingsAddObjectFile
     OrcV2CBindingsRemovableCode
     OrcV2CBindingsReflectProcessSymbols
+    OrcV2CBindingsLazy
     )
   if(CMAKE_HOST_UNIX)
     list(APPEND LLVM_TEST_DEPENDS
       LLJITWithRemoteDebugging
       )
   endif()
   if (NOT WIN32)
     list(APPEND LLVM_TEST_DEPENDS

llvm/test/Examples/OrcV2Examples/orcv2-cbindings-lazy.test

+# RUN: OrcV2CBindingsLazy 2>&1 | FileCheck -check-prefix=THIS %s
+# RUN: OrcV2CBindingsLazy 0 2>&1 | FileCheck -check-prefix=OTHER %s
+
+# THIS: entry(1) = 1
+# OTHER: entry(2) = 2

llvm/test/lit.cfg.py

tools.extend([
     ToolSubst('Kaleidoscope-Ch6', unresolved='ignore'),
     ToolSubst('Kaleidoscope-Ch7', unresolved='ignore'),
     ToolSubst('Kaleidoscope-Ch8', unresolved='ignore'),
     ToolSubst('LLJITWithThinLTOSummaries', unresolved='ignore'),
     ToolSubst('LLJITWithRemoteDebugging', unresolved='ignore'),
     ToolSubst('OrcV2CBindingsBasicUsage', unresolved='ignore'),
     ToolSubst('OrcV2CBindingsAddObjectFile', unresolved='ignore'),
     ToolSubst('OrcV2CBindingsRemovableCode', unresolved='ignore'),
-    ToolSubst('OrcV2CBindingsReflectProcessSymbols', unresolved='ignore')])
+    ToolSubst('OrcV2CBindingsReflectProcessSymbols', unresolved='ignore'),
+    ToolSubst('OrcV2CBindingsLazy', unresolved='ignore')])
 
 llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)
 
 # Targets
 
 config.targets = frozenset(config.targets_to_build.split())
 
 for arch in config.targets_to_build.split():