[Orc] Add verylazy example for C-bindings

[vchuravy]

Summary

Still WIP, based on the Kaleidoscope/BuildingAJIT/Chapter4.

[vchuravy]

@lhames this currently fails with

➜  build git:(vc/orcv2-lazy-capi) ✗ bin/OrcV2CBindingsVeryLazy 0
Error: Duplicate definition of symbol 'foo_body'
fish: Job 1, 'bin/OrcV2CBindingsVeryLazy 0' terminated by signal SIGSEGV (Address boundary error)

Should I have used independent JITDylibs or done a triple indirection foo -> foo_trampoline -> foo_body?

[vchuravy]

Use IRLayer::emit instead of LLJIT::add

[vchuravy]

Use MaterializationResponsibility::replace

[vchuravy]

Create separate MaterializationUnit's

[vchuravy]

clang-format and rebase

[vchuravy]

add first draft of docs and unit test for MaterializationResponisibility

[lhames]

I see a couple of warnings when building this code:

/path/to/llvm-project/llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.c:127:14: warning: variable 'TSM' is used uninitialized whenever 'if' condition is false [-Wsometimes-uninitialized]
  } else if (strcmp(CSym, "bar_body") == 0) {
             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/path/to/llvm-project/llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.c:133:10: note: uninitialized use occurs here
  assert(TSM);
         ^~~
/Library/Developer/CommandLineTools/SDKs/MacOSX11.5.sdk/usr/include/assert.h:93:25: note: expanded from macro 'assert'
    (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0)
                        ^
/path/to/llvm-project/llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.c:127:10: note: remove the 'if' if its condition is always true
  } else if (strcmp(CSym, "bar_body") == 0) {
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/path/to/llvm-project/llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.c:120:33: note: initialize the variable 'TSM' to silence this warning
  LLVMOrcThreadSafeModuleRef TSM;
                                ^
                                 = NULL

and it asserts on execution on Darwin with:

./bin/OrcV2CBindingsVeryLazy 
Assertion failed: ((!RequiresNullTerminator || BufEnd[0] == 0) && "Buffer is not null terminated!"), function init, file /path/to/llvm-project/llvm/lib/Support/MemoryBuffer.cpp, line 49.

I'll see if I can figure out what's going on there tomorrow.

Regarding the MaterializationResponsibility API: it would be good to add the addDependencies and addDependenciesForAll methods. These declare dependencies for each materializing symbol so that ORC can track them in its dependence graph, which in turn ensures that lookups remain safe regardless of what threads the symbols are being materialized on. These methods are an essential part of the MaterializationResponsibility API.

llvm/include/llvm-c/Orc.h

704–720

This can be removed for now, since the operation isn't supported in the C++ API yet.

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

475–484

I'll remove this function on the mainline. This code can be dropped from this review.

[vchuravy]

Address part of the review

[vchuravy]

Regarding the MaterializationResponsibility API: it would be good to add the addDependencies and addDependenciesForAll methods. These declare dependencies for each materializing symbol so that ORC can track them in its dependence graph, which in turn ensures that lookups remain safe regardless of what threads the symbols are being materialized on. These methods are an essential part of the MaterializationResponsibility API.

I added methods for both, but I haven't added a test yet. I marked in the unit tests which API methods for MR are not yet covered.

I think we also talked about the type hierarchy for the Layers and that in theory we should allow for some polymorphism instead of requiring specific types.

llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.c

149

@lhames am I right that I need to pass the LLJIT as the Context?

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

188

@lhames are you okay with making this public?

We need either that or a way to get the TM from LLJIT.
For Julia I copied the implementation https://github.com/maleadt/LLVM.jl/blob/600f5cd22252d12c64ff3e00f2921ba101323a70/deps/LLVMExtra/lib/orc.cpp#L229-L244

llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

380 ↗

(On Diff #357817)

400 ↗

(On Diff #357817)

@lhames the flags returned here are wrong so I might have a mistake somewhere in the conversion code.

409 ↗

(On Diff #357817)

@lhames Ideas for tests are appreciated :)

[lhames]

I found a few more issues while getting the example working on Darwin:

1. Rather than exposing applyDataLayout, it would be better to add an LLVMOrcLLJITGetDataLayoutString function, then use the existing LLVMSetDataLayout function.

2. You should uses strlen rather than sizeof when building the MemoryBuffers for the source -- MemoryBuffer's null termination guarantee is that the character one past the end of the buffer is null, so 'sizeof' causes assertions if the memory following the null terminator happens to be non-zero.

3. You should compares mangled+interned symbol names, rather than doing string comparisons on symbol names. That makes the example work regardless of the platform mangling scheme. (Side note: in a real world example we'd want to intern the comparison symbols once and re-use them, but the extra memory management felt like it would just complicate things here so I've opted to re-intern the strings on each call.)

4. You'll need to add a LLVMOrcDisposeMaterializationResponsibility function: MaterializationResponsibility objects are uniquely owned -- If you hand it off to a base layer you're off the hook, but if you fail the materialization you need a way to dispose of it. This should be called on MR after you fail the materialization in the example.

I've also added some inline notes about ownership in the comments.

llvm/include/llvm-c/Orc.h

615–622

typo in 'lenght'.

The comment should include a note that the pool entries are not retained by this operation: The entries need not be released, but must be retained if the caller wants them to outlive any mutating operations on the MR object.

626–628

This should include a note that it does not release the entries.

641–644

Should include a note that the returned entry is not retained -- the caller should retain it if they want it to outlive any mutating operations on the MR.

651

This should include a not that it only frees the list, it does not release the entries.

742–744

This should include a note that the function returns ownership of the instance, and the client is responsible for freeing it (after resolving/emitting, or failing).

[vchuravy]

Apply changes from lhames

[vchuravy]

Update docs

[vchuravy]

Update unittests

[vchuravy]

llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

432 ↗

(On Diff #357953)

@lhames any ideas what I am doing wrong here?

[lhames]

llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

432 ↗

(On Diff #357953)

-debug-only=orc tells the story:

In main defining materializing symbols { ("_other", [Callable]) }
In main replacing symbols with MU@0x10d721db0 ("<Absolute Symbols>", { ("_other", [Callable]) })
Adding dependencies for _foo: { (main, { _other }) }
In main adding dependencies for _foo: { (main, { _other }) }
Adding dependencies for all symbols in { ("_foo", [Callable]) }: { (main, { _other }) }
In main adding dependencies for _foo: { (main, { _other }) }
In main resolving { ("_foo": 0x00000001000eb8a0 [Callable]) }
In main emitting { ("_foo", [Callable]) }
Done dispatching MaterializationUnits.

You've hit a not-yet-considered corner case: Adding a dependency on a symbol (other) for which there is no corresponding lookup. Materialization is currently only triggered by lookup, not by adding dependencies, so the lookup for foo is left stuck (due to the dependence on other) with no way to trigger materialization of other.

A real test of the dependence tracking in the success case would require async lookups. You could:

1. Materialize foo, making foo depend on other.
2. In the caller, verify that the lookup callback for foo has not run (due to the dependence)
3. Materialize other by looking it up.
4. In the caller, verify that the lookup callback for foo has now run.

I don't think you need to implement the APIs required to test this though. For this test I would just go ahead and resolve/emit other too, then this should work.

Could you include a FIXME ('write async lookup API, then... ', and the steps listed above) in the test case so that we can go back and do it The Right Way in the future?

[vchuravy]

Update test for adding dependencies and clang-format

Good to go from my side

[lhames]

LGTM. This is great stuff -- thanks Valentin!

llvm/examples/OrcV2Examples/CMakeLists.txt

 add_subdirectory(LLJITWithThinLTOSummaries)
 add_subdirectory(OrcV2CBindingsAddObjectFile)
 add_subdirectory(OrcV2CBindingsBasicUsage)
 add_subdirectory(OrcV2CBindingsDumpObjects)
 add_subdirectory(OrcV2CBindingsIRTransforms)
 add_subdirectory(OrcV2CBindingsReflectProcessSymbols)
 add_subdirectory(OrcV2CBindingsRemovableCode)
 add_subdirectory(OrcV2CBindingsLazy)
+add_subdirectory(OrcV2CBindingsVeryLazy)
 
 if(CMAKE_HOST_UNIX)
   add_subdirectory(LLJITWithRemoteDebugging)
 endif()

llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/CMakeLists.txt

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

llvm/examples/OrcV2Examples/OrcV2CBindingsVeryLazy/OrcV2CBindingsVeryLazy.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 <assert.h>
+#include <stdio.h>
+#include <string.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 applyDataLayout(void *Ctx, LLVMModuleRef M) {
+  return LLVMOrcLLJITApplyDataLayout((LLVMOrcLLJITRef)Ctx, M);
+}
+
+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;
+}
+
+void Destroy(void *Ctx) {}
+
+void Materialize(void *Ctx, LLVMOrcMaterializationResponsibilityRef MR) {
+  int MainResult = 0;
+
+  size_t NumSymbols;
+  LLVMOrcSymbolStringPoolEntryRef *Symbols =
+      LLVMOrcMaterializationResponsibilityGetRequestedSymbols(MR, &NumSymbols);
+
+  assert(NumSymbols == 1);
+
+  LLVMOrcSymbolStringPoolEntryRef Sym = Symbols[0];
+  const char *CSym = LLVMOrcSymbolStringPoolEntryStr(Sym);
+
+  LLVMOrcThreadSafeModuleRef TSM;
+  LLVMErrorRef Err;
+  if (strcmp(CSym, "foo_body") == 0) {
+    if ((Err = parseExampleModule(FooMod, sizeof(FooMod), "foo-mod", &TSM))) {
+      MainResult = handleError(Err);
+      goto cleanup;
+    }
+  } else if (strcmp(CSym, "bar_body") == 0) {
+    if ((Err = parseExampleModule(BarMod, sizeof(BarMod), "bar-mod", &TSM))) {
+      MainResult = handleError(Err);
+      goto cleanup;
+    }
+  }
+  assert(TSM);
+
+  if ((Err = LLVMOrcThreadSafeModuleWithModuleDo(TSM, &applyDataLayout, Ctx))) {
+    MainResult = handleError(Err);
+    goto cleanup;
+  }
+
+cleanup:
+  LLVMOrcDisposeSymbols(Symbols);
+  if (MainResult == 1) {
+    LLVMOrcMaterializationResponsibilityFailMaterialization(MR);
+  } else {
+    // Question@lhames: Better way to get LLVMOrcLLJITRef J;
+    LLVMOrcLLJITRef J = (LLVMOrcLLJITRef)Ctx;
+    LLVMOrcIRTransformLayerRef IRLayer = LLVMOrcLLJITGetIRTransformLayer(J);
+    LLVMOrcIRTransformLayerEmit(IRLayer, MR, TSM);
+  }
+  return;
+}
+
+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 main module to the JIT.
+  {
+    LLVMOrcJITDylibRef MainJD = LLVMOrcLLJITGetMainJITDylib(J);
+    LLVMErrorRef Err;
+
+    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;
+    }
+  }
+
+  LLVMJITSymbolFlags Flags = {
+      LLVMJITSymbolGenericFlagsExported | LLVMJITSymbolGenericFlagsCallable, 0};
+  LLVMOrcCSymbolFlagsMapPair FooSym = {
+      LLVMOrcLLJITMangleAndIntern(J, "foo_body"), Flags};
+  LLVMOrcCSymbolFlagsMapPair BarSym = {
+      LLVMOrcLLJITMangleAndIntern(J, "bar_body"), Flags};
+
+  // add custom MaterializationUnit
+  {
+    LLVMOrcMaterializationUnitRef FooMU =
+        LLVMOrcCreateCustomMaterializationUnit("FooMU", J, &FooSym, 1, NULL,
+                                               &Materialize, NULL, &Destroy);
+
+    LLVMOrcMaterializationUnitRef BarMU =
+        LLVMOrcCreateCustomMaterializationUnit("BarMU", J, &BarSym, 1, NULL,
+                                               &Materialize, NULL, &Destroy);
+
+    LLVMOrcJITDylibRef MainJD = LLVMOrcLLJITGetMainJITDylib(J);
+    LLVMOrcJITDylibDefine(MainJD, FooMU);
+    LLVMOrcJITDylibDefine(MainJD, BarMU);
+  }
+
+  // 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;
+    }
+  }
+
+  LLVMOrcCSymbolAliasMapPair ReExports[2] = {
+      {LLVMOrcLLJITMangleAndIntern(J, "foo"),
+       {LLVMOrcLLJITMangleAndIntern(J, "foo_body"), Flags}},
+      {LLVMOrcLLJITMangleAndIntern(J, "bar"),
+       {LLVMOrcLLJITMangleAndIntern(J, "bar_body"), Flags}},
+  };
+
+  {
+    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/LLJIT.h

 LLVMOrcObjectTransformLayerRef
 LLVMOrcLLJITGetObjTransformLayer(LLVMOrcLLJITRef J);
 
 /**
  * Returns a non-owning reference to the LLJIT instance's IR transform layer.
  */
 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J);
 
+LLVMErrorRef LLVMOrcLLJITApplyDataLayout(LLVMOrcLLJITRef J, LLVMModuleRef Mod);
+
+LLVMOrcManglingOptionsRef LLVMOrcLLJITGetManglingOptions(LLVMOrcLLJITRef J);
+
 LLVM_C_EXTERN_C_END
 
 #endif /* LLVM_C_LLJIT_H */

llvm/include/llvm-c/Orc.h

  */
 typedef LLVMOrcCLookupSetElement *LLVMOrcCLookupSet;
 
 /**
  * A reference to a uniquely owned orc::MaterializationUnit instance.
  */
 typedef struct LLVMOrcOpaqueMaterializationUnit *LLVMOrcMaterializationUnitRef;
 
+typedef struct LLVMOrcOpaqueManglingOptions *LLVMOrcManglingOptionsRef;
+
 /**
  * A reference to a uniquely owned orc::MaterializationResponsibility instance.
  *
  * Ownership must be passed to a lower-level layer in a JIT stack.
  */
 typedef struct LLVMOrcOpaqueMaterializationResponsibility
     *LLVMOrcMaterializationResponsibilityRef;
 

  * 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
 
+LLVMOrcMaterializationUnitRef
+LLVMOrcCreateIRMaterializationUnit(LLVMOrcIRTransformLayerRef IL,
+                                   LLVMOrcThreadSafeModuleRef TSM);
+
+LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+// TODO(vchuravy) Test
+LLVMOrcExecutionSessionRef
+LLVMOrcMaterializationResponsibilityGetExecutionSession(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+// TODO(vchuravy) Test
+LLVMOrcSymbolStringPoolEntryRef
+LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+LLVMOrcSymbolStringPoolEntryRef *
+LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
+    LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols);
+
+void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols);
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
+    LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
+    size_t NumPairs);
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+// TODO(vchuravy) Test
+LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
+    LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Syms,
+    size_t NumPairs);
+
+void LLVMOrcMaterializationResponsibilityDefineNonExistent(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols);
+
+void LLVMOrcMaterializationResponsibilityFailMaterialization(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcMaterializationUnitRef MU);
+
+LLVMOrcMaterializationResponsibilityRef
+LLVMOrcMaterializationResponsibilityDelegate(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols);
+
+// MaterializationResponsibility::delegate
+// MaterializationResponsibility::addDependencies
+// MaterializationResponsibility::addDependenciesForAll
+
 /**
  * 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.

  * Return a reference to a newly created resource tracker associated with JD.
  * The tracker is returned with an initial ref-count of 1, and must be released
  * with LLVMOrcReleaseResourceTracker when no longer needed.
  */
 LLVMOrcResourceTrackerRef
 LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD);
 
 /**
  * Return a reference to the default resource tracker for the given JITDylib.
  * This operation will increase the retain count of the tracker: Clients should
  * call LLVMOrcReleaseResourceTracker when the result is no longer needed.
  */
 LLVMOrcResourceTrackerRef
 LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD);
 
 /**
  * Add the given MaterializationUnit to the given JITDylib.
  *
  * If this operation succeeds then JITDylib JD will take ownership of MU.
  * If the operation fails then ownership remains with the caller who should
  * call LLVMOrcDisposeMaterializationUnit to destroy it.
  */
 LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,
                                    LLVMOrcMaterializationUnitRef MU);
 
 /**
  * Calls remove on all trackers associated with this JITDylib, see
  * JITDylib::clear().
  */
 LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD);
 
 /**
  * Add a DefinitionGenerator to the given JITDylib.
  *
  * The JITDylib will take ownership of the given generator: The client is no
  * longer responsible for managing its memory.
  */
 void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,
                                  LLVMOrcDefinitionGeneratorRef DG);
 
 /**
  * Create a custom generator.
  */
 LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator(
     LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx);
 
 /**
  * Get a DynamicLibrarySearchGenerator that will reflect process symbols into
  * the JITDylib. On success the resulting generator is owned by the client.
  * Ownership is typically transferred by adding the instance to a JITDylib
  * using LLVMOrcJITDylibAddGenerator,
  *
  * The GlobalPrefix argument specifies the character that appears on the front
  * of linker-mangled symbols for the target platform (e.g. '_' on MachO).
  * If non-null, this character will be stripped from the start of all symbol
  * strings before passing the remaining substring to dlsym.
  *
void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
                             LLVMOrcMaterializationResponsibilityRef R,
                             LLVMMemoryBufferRef ObjBuffer);
 
 /**
  * Dispose of an ObjectLayer.
  */
 void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer);
 
+void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRTransformLayer,
+                                 LLVMOrcMaterializationResponsibilityRef MR,
+                                 LLVMOrcThreadSafeModuleRef TSM);
+
 /**
  * Set the transform function of the provided transform layer, passing through a
  * pointer to user provided context.
  */
 void LLVMOrcIRTransformLayerSetTransform(
     LLVMOrcIRTransformLayerRef IRTransformLayer,
     LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx);
 

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

public:
   /// Returns a linker-mangled version of UnmangledName.
   std::string mangle(StringRef UnmangledName) const;
 
   /// Returns an interned, linker-mangled version of UnmangledName.
   SymbolStringPtr mangleAndIntern(StringRef UnmangledName) const {
     return ES->intern(mangle(UnmangledName));
   }
 
+  Error applyDataLayout(Module &M);
+
 protected:
   static Expected<std::unique_ptr<ObjectLayer>>
   createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES);
 
   static Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
   createCompileFunction(LLJITBuilderState &S, JITTargetMachineBuilder JTMB);
 
   /// Create an LLJIT instance with a single compile thread.
   LLJIT(LLJITBuilderState &S, Error &Err);
 
-  Error applyDataLayout(Module &M);
 
   void recordCtorDtors(Module &M);
 
   std::unique_ptr<ExecutionSession> ES;
   std::unique_ptr<PlatformSupport> PS;
 
   JITDylib *Main = nullptr;
 

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionSession, LLVMOrcExecutionSessionRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SymbolStringPool, LLVMOrcSymbolStringPoolRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcV2CAPIHelper::PoolEntry,
                                    LLVMOrcSymbolStringPoolEntryRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationUnit,
                                    LLVMOrcMaterializationUnitRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MaterializationResponsibility,
                                    LLVMOrcMaterializationResponsibilityRef)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRSymbolMapper::ManglingOptions,
+                                   LLVMOrcManglingOptionsRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITDylib, LLVMOrcJITDylibRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ResourceTracker, LLVMOrcResourceTrackerRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DefinitionGenerator,
                                    LLVMOrcDefinitionGeneratorRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(InProgressLookupState, LLVMOrcLookupStateRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeContext,
                                    LLVMOrcThreadSafeContextRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ThreadSafeModule, LLVMOrcThreadSafeModuleRef)
static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) {
   if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly)
     JSF |= JITSymbolFlags::MaterializationSideEffectsOnly;
 
   JSF.getTargetFlags() = F.TargetFlags;
 
   return JSF;
 }
 
+static SymbolMap toSymbolMap(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
+  SymbolMap SM;
+  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 SM;
+}
+
 } // end anonymous namespace
 
 void LLVMOrcExecutionSessionSetErrorReporter(
     LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError,
     void *Ctx) {
   unwrap(ES)->setErrorReporter(
       [=](Error Err) { ReportError(Ctx, wrap(std::move(Err))); });
 }
LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit(
   auto IS = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(InitSym));
 
   return wrap(new OrcCAPIMaterializationUnit(
       Name, std::move(SFM), std::move(IS), Ctx, Materialize, Discard, Destroy));
 }
 
 LLVMOrcMaterializationUnitRef
 LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs) {
-  SymbolMap SM;
-  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);
-  }
-
+  SymbolMap SM = toSymbolMap(Syms, NumPairs);
   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());
 }
 
+LLVMOrcMaterializationUnitRef
+LLVMOrcCreateIRMaterializationUnit(LLVMOrcIRTransformLayerRef IRLayer,
+                                   LLVMOrcThreadSafeModuleRef TSM) {
+  std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
+  // std::unique_ptr<IRTransformLayer> TmpIL(unwrap(IRLayer));
+  auto MU = std::make_unique<BasicIRLayerMaterializationUnit>(
+      *unwrap(IRLayer), *(unwrap(IRLayer)->getManglingOptions()),
+      std::move(*TmpTSM));
+  return wrap(MU.release());
+}
+
+LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  return wrap(&unwrap(MR)->getTargetJITDylib());
+}
+
+LLVMOrcExecutionSessionRef
+LLVMOrcMaterializationResponsibilityGetExecutionSession(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  return wrap(&unwrap(MR)->getExecutionSession());
+}
+
+LLVMOrcSymbolStringPoolEntryRef
+LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  auto Sym = unwrap(MR)->getInitializerSymbol();
+  return wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Sym));
+}
+
+LLVMOrcSymbolStringPoolEntryRef *
+LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
+    LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols) {
+
+  auto Symbols = unwrap(MR)->getRequestedSymbols();
+  LLVMOrcSymbolStringPoolEntryRef *Result =
+      static_cast<LLVMOrcSymbolStringPoolEntryRef *>(safe_malloc(
+          Symbols.size() * sizeof(LLVMOrcSymbolStringPoolEntryRef)));
+  size_t I = 0;
+  for (auto &Name : Symbols) {
+    Result[I] = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(Name));
+    I++;
+  }
+  *NumSymbols = Symbols.size();
+  return Result;
+}
+
+void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols) {
+  free(Symbols);
+}
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
+    LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
+    size_t NumPairs) {
+  SymbolMap SM = toSymbolMap(Symbols, NumPairs);
+  return wrap(unwrap(MR)->notifyResolved(std::move(SM)));
+}
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  return wrap(unwrap(MR)->notifyEmitted());
+}
+
+// TODO(vchuravy) Test
+LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcCSymbolFlagsMapPairs Syms, size_t NumSyms) {
+  SymbolFlagsMap SFM;
+  for (size_t I = 0; I != NumSyms; ++I)
+    SFM[OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Syms[I].Name))] =
+        toJITSymbolFlags(Syms[I].Flags);
+
+  return wrap(unwrap(MR)->defineMaterializing(std::move(SFM)));
+}
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcMaterializationUnitRef MU) {
+  std::unique_ptr<MaterializationUnit> TmpMU(unwrap(MU));
+  return wrap(unwrap(MR)->replace(std::move(TmpMU)));
+}
+
+LLVMOrcMaterializationResponsibilityRef
+LLVMOrcMaterializationResponsibilityDelegate(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols) {
+  SymbolNameSet Syms;
+  for (size_t I = 0; I != NumSymbols; I++) {
+    Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I])));
+  }
+  return wrap(unwrap(MR)->delegate(Syms)->release());
+}
+
+// TODO(@lhames) MaterializationResponsibility::defineNonExistent is nonExistent
+// void LLVMOrcMaterializationResponsibilityDefineNonExistent(
+//     LLVMOrcMaterializationResponsibilityRef MR,
+//     LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols) {
+//   SmallVector<SymbolStringPtr, 4> Syms;
+//   for (size_t I = 0; I != NumSymbols; I++) {
+//     Syms.push_back(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I])));
+//   }
+//   unwrap(MR)->defineNonExistent(Syms);
+// }
+
+void LLVMOrcMaterializationResponsibilityFailMaterialization(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  unwrap(MR)->failMaterialization();
+}
+
+void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRLayer,
+                                 LLVMOrcMaterializationResponsibilityRef MR,
+                                 LLVMOrcThreadSafeModuleRef TSM) {
+  std::unique_ptr<ThreadSafeModule> TmpTSM(unwrap(TSM));
+  unwrap(IRLayer)->emit(
+      std::unique_ptr<MaterializationResponsibility>(unwrap(MR)),
+      std::move(*TmpTSM));
+}
+
 LLVMOrcJITDylibRef
 LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
                                           const char *Name) {
   return wrap(&unwrap(ES)->createBareJITDylib(Name));
 }
 
 LLVMErrorRef
 LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
void LLVMOrcRTDyldObjectLinkingLayerRegisterJITEventListener(
   reinterpret_cast<RTDyldObjectLinkingLayer *>(unwrap(RTDyldObjLinkingLayer))
       ->registerJITEventListener(*unwrap(Listener));
 }
 
 LLVMOrcIRTransformLayerRef LLVMOrcLLJITGetIRTransformLayer(LLVMOrcLLJITRef J) {
   return wrap(&unwrap(J)->getIRTransformLayer());
 }
 
+LLVMErrorRef LLVMOrcLLJITApplyDataLayout(LLVMOrcLLJITRef J, LLVMModuleRef Mod) {
+  return wrap(unwrap(J)->applyDataLayout(*unwrap(Mod)));
+}
+
 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));

llvm/test/CMakeLists.txt

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

llvm/test/lit.cfg.py

tools.extend([
     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('OrcV2CBindingsLazy', unresolved='ignore')])
+    ToolSubst('OrcV2CBindingsLazy', unresolved='ignore'),
+    ToolSubst('OrcV2CBindingsVeryLazy', 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():