[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

725–741

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

llvm/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

505–514

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 ↗

(On Diff #357817)

@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

400

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

409

@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

636–643

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.

647–649

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

662–665

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.

672

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

763–765

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

@lhames any ideas what I am doing wrong here?

[lhames]

llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

432

-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) {
+  LLVMSetDataLayout(M, LLVMOrcLLJITGetDataLayoutStr((LLVMOrcLLJITRef)Ctx));
+  return LLVMErrorSuccess;
+}
+
+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, 1);
+
+  // Parse the LLVM module.
+  LLVMModuleRef M;
+  char *ErrMsg;
+  if (LLVMParseIRInContext(Ctx, MB, &M, &ErrMsg)) {
+    LLVMErrorRef Err = LLVMCreateStringError(ErrMsg);
+    LLVMDisposeMessage(ErrMsg);
+    return Err;
+  }
+
+  // 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);
+
+  LLVMOrcLLJITRef J = (LLVMOrcLLJITRef)Ctx;
+  LLVMOrcSymbolStringPoolEntryRef Sym = Symbols[0];
+
+  LLVMOrcThreadSafeModuleRef TSM = 0;
+  LLVMErrorRef Err;
+
+  LLVMOrcSymbolStringPoolEntryRef FooBody =
+      LLVMOrcLLJITMangleAndIntern(J, "foo_body");
+  LLVMOrcSymbolStringPoolEntryRef BarBody =
+      LLVMOrcLLJITMangleAndIntern(J, "bar_body");
+
+  if (Sym == FooBody) {
+    if ((Err = parseExampleModule(FooMod, strlen(FooMod), "foo-mod", &TSM))) {
+      MainResult = handleError(Err);
+      goto cleanup;
+    }
+  } else if (Sym == BarBody) {
+    if ((Err = parseExampleModule(BarMod, strlen(BarMod), "bar-mod", &TSM))) {
+      MainResult = handleError(Err);
+      goto cleanup;
+    }
+  } else {
+    MainResult = 1;
+    goto cleanup;
+  }
+  assert(TSM);
+
+  if ((Err = LLVMOrcThreadSafeModuleWithModuleDo(TSM, &applyDataLayout, Ctx))) {
+    MainResult = handleError(Err);
+    goto cleanup;
+  }
+
+cleanup:
+  LLVMOrcReleaseSymbolStringPoolEntry(BarBody);
+  LLVMOrcReleaseSymbolStringPoolEntry(FooBody);
+  LLVMOrcDisposeSymbols(Symbols);
+  if (MainResult == 1) {
+    LLVMOrcMaterializationResponsibilityFailMaterialization(MR);
+    LLVMOrcDisposeMaterializationResponsibility(MR);
+  } else {
+    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, strlen(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);
 
+/**
+ * Get the LLJIT instance's default data layout string.
+ *
+ * This string is owned by the LLJIT instance and does not need to be freed
+ * by the caller.
+ */
+const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J);
+
 LLVM_C_EXTERN_C_END
 
 #endif /* LLVM_C_LLJIT_H */

llvm/include/llvm-c/Orc.h

 
 /**
  * Represents a list of (SymbolStringPtr, (SymbolStringPtr, JITSymbolFlags))
  * pairs that can be used to construct a SymbolFlagsMap.
  */
 typedef LLVMOrcCSymbolAliasMapPair *LLVMOrcCSymbolAliasMapPairs;
 
 /**
+ * A reference to an orc::JITDylib instance.
+ */
+typedef struct LLVMOrcOpaqueJITDylib *LLVMOrcJITDylibRef;
+
+/**
+ * Represents a list of LLVMOrcSymbolStringPoolEntryRef and the associated
+ * length.
+ */
+typedef struct {
+  LLVMOrcSymbolStringPoolEntryRef *Symbols;
+  size_t Length;
+} LLVMOrcCSymbolsList;
+
+/**
+ * Represents a pair of a JITDylib and LLVMOrcCSymbolsList.
+ */
+typedef struct {
+  LLVMOrcJITDylibRef JD;
+  LLVMOrcCSymbolsList Names;
+} LLVMOrcCDependenceMapPair;
+
+/**
+ * Represents a list of (JITDylibRef, (LLVMOrcSymbolStringPoolEntryRef*,
+ * size_t)) pairs that can be used to construct a SymbolDependenceMap.
+ */
+typedef LLVMOrcCDependenceMapPair *LLVMOrcCDependenceMapPairs;
+
+/**
  * 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

  * 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;
 
 /**
- * A reference to an orc::JITDylib instance.
- */
-typedef struct LLVMOrcOpaqueJITDylib *LLVMOrcJITDylibRef;
-
-/**
  * A MaterializationUnit materialize callback.
  *
  * Ownership of the Ctx and MR arguments passes to the callback which must
  * adhere to the LLVMOrcMaterializationResponsibilityRef contract (see comment
  * for that type).
  *
  * If this callback is called then the LLVMOrcMaterializationUnitDestroy
  * callback will NOT be called.

  */
 LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
     LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
     LLVMOrcJITDylibRef SourceRef, LLVMOrcCSymbolAliasMapPairs CallableAliases,
     size_t NumPairs);
 // TODO: ImplSymbolMad SrcJDLoc
 
 /**
+ * Disposes of the passed MaterializationResponsibility object.
+ *
+ * This should only be done after the symbols covered by the object have either
+ * been resolved and emitted (via
+ * LLVMOrcMaterializationResponsibilityNotifyResolved and
+ * LLVMOrcMaterializationResponsibilityNotifyEmitted) or failed (via
+ * LLVMOrcMaterializationResponsibilityFailMaterialization).
+ */
+void LLVMOrcDisposeMaterializationResponsibility(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Returns the target JITDylib that these symbols are being materialized into.
+ */
+LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Returns the ExecutionSession for this MaterializationResponsibility.
+ */
+LLVMOrcExecutionSessionRef
+LLVMOrcMaterializationResponsibilityGetExecutionSession(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Returns the symbol flags map for this responsibility instance.
+ *
+ * The length of the array is returned in NumPairs and the caller is responsible
+ * for the returned memory and needs to call LLVMOrcDisposeCSymbolFlagsMap.
+ *
+ * To use the returned symbols beyond the livetime of the
+ * MaterializationResponsibility requires the caller to retain the symbols
+ * explicitly.
+ */
+LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
+    LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs);
+
+/**
+ * Disposes of the passed LLVMOrcCSymbolFlagsMap.
+ *
+ * Does not release the entries themselves.
+ */
+void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs);
+
+/**
+ * Returns the initialization pseudo-symbol, if any. This symbol will also
+ * be present in the SymbolFlagsMap for this MaterializationResponsibility
+ * object.
+ *
+ * The returned symbol is not retained over any mutating operation of the
+ * MaterializationResponsbility or beyond the lifetime thereof.
+ */
+LLVMOrcSymbolStringPoolEntryRef
+LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Returns the names of any symbols covered by this
+ * MaterializationResponsibility object that have queries pending. This
+ * information can be used to return responsibility for unrequested symbols
+ * back to the JITDylib via the delegate method.
+ */
+LLVMOrcSymbolStringPoolEntryRef *
+LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
+    LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols);
+
+/**
+ * Disposes of the passed LLVMOrcSymbolStringPoolEntryRef* .
+ *
+ * Does not release the symbols themselves.
+ */
+void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols);
+
+/*
+ * Notifies the target JITDylib that the given symbols have been resolved.
+ * This will update the given symbols' addresses in the JITDylib, and notify
+ * any pending queries on the given symbols of their resolution. The given
+ * symbols must be ones covered by this MaterializationResponsibility
+ * instance. Individual calls to this method may resolve a subset of the
+ * symbols, but all symbols must have been resolved prior to calling emit.
+ *
+ * This method will return an error if any symbols being resolved have been
+ * moved to the error state due to the failure of a dependency. If this
+ * method returns an error then clients should log it and call
+ * LLVMOrcMaterializationResponsibilityFailMaterialization. If no dependencies
+ * have been registered for the symbols covered by this
+ * MaterializationResponsibiility then this method is guaranteed to return
+ * LLVMErrorSuccess.
+ */
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
+    LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
+    size_t NumPairs);
+
+/**
+ * Notifies the target JITDylib (and any pending queries on that JITDylib)
+ * that all symbols covered by this MaterializationResponsibility instance
+ * have been emitted.
+ *
+ * This method will return an error if any symbols being resolved have been
+ * moved to the error state due to the failure of a dependency. If this
+ * method returns an error then clients should log it and call
+ * LLVMOrcMaterializationResponsibilityFailMaterialization.
+ * If no dependencies have been registered for the symbols covered by this
+ * MaterializationResponsibiility then this method is guaranteed to return
+ * LLVMErrorSuccess.
+ */
+LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Attempt to claim responsibility for new definitions. This method can be
+ * used to claim responsibility for symbols that are added to a
+ * materialization unit during the compilation process (e.g. literal pool
+ * symbols). Symbol linkage rules are the same as for symbols that are
+ * defined up front: duplicate strong definitions will result in errors.
+ * Duplicate weak definitions will be discarded (in which case they will
+ * not be added to this responsibility instance).
+ *
+ * This method can be used by materialization units that want to add
+ * additional symbols at materialization time (e.g. stubs, compile
+ * callbacks, metadata)
+ */
+LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcCSymbolFlagsMapPairs Pairs, size_t NumPairs);
+
+/**
+ * Notify all not-yet-emitted covered by this MaterializationResponsibility
+ * instance that an error has occurred.
+ * This will remove all symbols covered by this MaterializationResponsibilty
+ * from the target JITDylib, and send an error to any queries waiting on
+ * these symbols.
+ */
+void LLVMOrcMaterializationResponsibilityFailMaterialization(
+    LLVMOrcMaterializationResponsibilityRef MR);
+
+/**
+ * Transfers responsibility to the given MaterializationUnit for all
+ * symbols defined by that MaterializationUnit. This allows
+ * materializers to break up work based on run-time information (e.g.
+ * by introspecting which symbols have actually been looked up and
+ * materializing only those).
+ */
+LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcMaterializationUnitRef MU);
+
+/**
+ * Delegates responsibility for the given symbols to the returned
+ * materialization responsibility. Useful for breaking up work between
+ * threads, or different kinds of materialization processes.
+ *
+ * The caller retains responsibility of the the passed
+ * MaterializationResponsibility.
+ */
+LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
+    LLVMOrcMaterializationResponsibilityRef *Result);
+
+/**
+ * Adds dependencies to a symbol that the MaterializationResponsibility is
+ * responsible for.
+ *
+ * This function takes ownership of Dependencies struct. The Names
+ * array have been retained for this function. This allows the following
+ * pattern...
+ *
+ *   LLVMOrcSymbolStringPoolEntryRef Names[] = {...};
+ *   LLVMOrcCDependenceMapPair Dependence = {JD, {Names, sizeof(Names)}}
+ *   LLVMOrcMaterializationResponsibilityAddDependencies(JD, Name, &Dependence,
+ * 1);
+ *
+ * ... without requiring cleanup of the elements of the Names array afterwards.
+ *
+ * The client is still responsible for deleting the Dependencies.Names array
+ * itself.
+ */
+void LLVMOrcMaterializationResponsibilityAddDependencies(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef Name,
+    LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs);
+
+/**
+ * Adds dependencies to all symbols that the MaterializationResponsibility is
+ * responsible for. See LLVMOrcMaterializationResponsibilityAddDependencies for
+ * notes about memory responsibility.
+ */
+void LLVMOrcMaterializationResponsibilityAddDependenciesForAll(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs);
+
+/**
  * 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.
  */
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/lib/ExecutionEngine/Orc/OrcV2CBindings.cpp

static JITSymbolFlags toJITSymbolFlags(LLVMJITSymbolFlags F) {
   if (F.GenericFlags & LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly)
     JSF |= JITSymbolFlags::MaterializationSideEffectsOnly;
 
   JSF.getTargetFlags() = F.TargetFlags;
 
   return JSF;
 }
 
+static LLVMJITSymbolFlags fromJITSymbolFlags(JITSymbolFlags JSF) {
+  LLVMJITSymbolFlags F = {0, 0};
+  if (JSF & JITSymbolFlags::Exported)
+    F.GenericFlags |= LLVMJITSymbolGenericFlagsExported;
+  if (JSF & JITSymbolFlags::Weak)
+    F.GenericFlags |= LLVMJITSymbolGenericFlagsWeak;
+  if (JSF & JITSymbolFlags::Callable)
+    F.GenericFlags |= LLVMJITSymbolGenericFlagsCallable;
+  if (JSF & JITSymbolFlags::MaterializationSideEffectsOnly)
+    F.GenericFlags |= LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly;
+
+  F.TargetFlags = JSF.getTargetFlags();
+
+  return F;
+}
+
+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;
+}
+
+static SymbolDependenceMap
+toSymbolDependenceMap(LLVMOrcCDependenceMapPairs Pairs, size_t NumPairs) {
+  SymbolDependenceMap SDM;
+  for (size_t I = 0; I != NumPairs; ++I) {
+    JITDylib *JD = unwrap(Pairs[I].JD);
+    SymbolNameSet Names;
+
+    for (size_t J = 0; J != Pairs[I].Names.Length; ++J) {
+      auto Sym = Pairs[I].Names.Symbols[J];
+      Names.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Sym)));
+    }
+    SDM[JD] = Names;
+  }
+  return SDM;
+}
+
 } // 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());
 }
 
+void LLVMOrcDisposeMaterializationResponsibility(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  std::unique_ptr<MaterializationResponsibility> TmpMR(unwrap(MR));
+}
+
+LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  return wrap(&unwrap(MR)->getTargetJITDylib());
+}
+
+LLVMOrcExecutionSessionRef
+LLVMOrcMaterializationResponsibilityGetExecutionSession(
+    LLVMOrcMaterializationResponsibilityRef MR) {
+  return wrap(&unwrap(MR)->getExecutionSession());
+}
+
+LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
+    LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs) {
+
+  auto Symbols = unwrap(MR)->getSymbols();
+  LLVMOrcCSymbolFlagsMapPairs Result = static_cast<LLVMOrcCSymbolFlagsMapPairs>(
+      safe_malloc(Symbols.size() * sizeof(LLVMOrcCSymbolFlagsMapPair)));
+  size_t I = 0;
+  for (auto const &pair : Symbols) {
+    auto Name = wrap(OrcV2CAPIHelper::getRawPoolEntryPtr(pair.first));
+    auto Flags = pair.second;
+    Result[I] = {Name, fromJITSymbolFlags(Flags)};
+    I++;
+  }
+  *NumPairs = Symbols.size();
+  return Result;
+}
+
+void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs) {
+  free(Pairs);
+}
+
+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());
+}
+
+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)));
+}
+
+LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
+    LLVMOrcMaterializationResponsibilityRef *Result) {
+  SymbolNameSet Syms;
+  for (size_t I = 0; I != NumSymbols; I++) {
+    Syms.insert(OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Symbols[I])));
+  }
+  auto OtherMR = unwrap(MR)->delegate(Syms);
+
+  if (!OtherMR) {
+    return wrap(OtherMR.takeError());
+  }
+  *Result = wrap(OtherMR->release());
+  return LLVMErrorSuccess;
+}
+
+void LLVMOrcMaterializationResponsibilityAddDependencies(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcSymbolStringPoolEntryRef Name,
+    LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
+
+  SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
+  auto Sym = OrcV2CAPIHelper::moveToSymbolStringPtr(unwrap(Name));
+  unwrap(MR)->addDependencies(Sym, SDM);
+}
+
+void LLVMOrcMaterializationResponsibilityAddDependenciesForAll(
+    LLVMOrcMaterializationResponsibilityRef MR,
+    LLVMOrcCDependenceMapPairs Dependencies, size_t NumPairs) {
+
+  SymbolDependenceMap SDM = toSymbolDependenceMap(Dependencies, NumPairs);
+  unwrap(MR)->addDependenciesForAll(SDM);
+}
+
+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());
 }
 
+const char *LLVMOrcLLJITGetDataLayoutStr(LLVMOrcLLJITRef J) {
+  return unwrap(J)->getDataLayout().getStringRepresentation().c_str();
+}
+
 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():

llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

TEST_F(OrcCAPITestBase, ExecutionTest) {
   LLVMOrcJITTargetAddress TestFnAddr;
   if (LLVMErrorRef E = LLVMOrcLLJITLookup(Jit, &TestFnAddr, "sum"))
     FAIL() << "Symbol \"sum\" was not added into JIT (triple = " << TargetTriple
            << "): " << toString(E);
   auto *SumFn = (SumFunctionType)(TestFnAddr);
   int32_t Result = SumFn(1, 1);
   ASSERT_EQ(2, Result);
 }
+
+void Destroy(void *Ctx) {}
+
+void TargetFn() {}
+
+void Materialize(void *Ctx, LLVMOrcMaterializationResponsibilityRef MR) {
+  LLVMOrcJITDylibRef JD =
+      LLVMOrcMaterializationResponsibilityGetTargetDylib(MR);
+  ASSERT_TRUE(!!JD);
+
+  LLVMOrcExecutionSessionRef ES =
+      LLVMOrcMaterializationResponsibilityGetExecutionSession(MR);
+  ASSERT_TRUE(!!ES);
+
+  LLVMOrcSymbolStringPoolEntryRef InitSym =
+      LLVMOrcMaterializationResponsibilityGetInitializerSymbol(MR);
+  ASSERT_TRUE(!InitSym);
+
+  size_t NumSymbols;
+  LLVMOrcCSymbolFlagsMapPairs Symbols =
+      LLVMOrcMaterializationResponsibilityGetSymbols(MR, &NumSymbols);
+
+  ASSERT_TRUE(!!Symbols);
+  ASSERT_EQ(NumSymbols, (size_t)1);
+
+  LLVMOrcSymbolStringPoolEntryRef *RequestedSymbols =
+      LLVMOrcMaterializationResponsibilityGetRequestedSymbols(MR, &NumSymbols);
+
+  ASSERT_TRUE(!!RequestedSymbols);
+  ASSERT_EQ(NumSymbols, (size_t)1);
+
+  LLVMOrcCSymbolFlagsMapPair TargetSym = Symbols[0];
+
+  ASSERT_EQ(RequestedSymbols[0], TargetSym.Name);
+  LLVMOrcRetainSymbolStringPoolEntry(TargetSym.Name);
+
+  LLVMOrcDisposeCSymbolFlagsMap(Symbols);
+  LLVMOrcDisposeSymbols(RequestedSymbols);
+
+  LLVMOrcJITTargetAddress Addr = (LLVMOrcJITTargetAddress)(&TargetFn);
+
+  LLVMJITSymbolFlags Flags = {
+      LLVMJITSymbolGenericFlagsExported | LLVMJITSymbolGenericFlagsCallable, 0};
+  ASSERT_EQ(TargetSym.Flags.GenericFlags, Flags.GenericFlags);
+  ASSERT_EQ(TargetSym.Flags.TargetFlags, Flags.TargetFlags);
+
+  LLVMJITEvaluatedSymbol Sym = {Addr, Flags};
+
+  LLVMOrcLLJITRef J = (LLVMOrcLLJITRef)Ctx;
+
+  LLVMOrcSymbolStringPoolEntryRef OtherSymbol =
+      LLVMOrcLLJITMangleAndIntern(J, "other");
+  LLVMOrcSymbolStringPoolEntryRef DependencySymbol =
+      LLVMOrcLLJITMangleAndIntern(J, "dependency");
+
+  LLVMOrcRetainSymbolStringPoolEntry(OtherSymbol);
+  LLVMOrcRetainSymbolStringPoolEntry(DependencySymbol);
+  LLVMOrcCSymbolFlagsMapPair NewSymbols[] = {
+      {OtherSymbol, Flags},
+      {DependencySymbol, Flags},
+  };
+  LLVMOrcMaterializationResponsibilityDefineMaterializing(MR, NewSymbols, 2);
+
+  LLVMOrcRetainSymbolStringPoolEntry(OtherSymbol);
+  LLVMOrcMaterializationResponsibilityRef OtherMR = NULL;
+  {
+    LLVMErrorRef Err = LLVMOrcMaterializationResponsibilityDelegate(
+        MR, &OtherSymbol, 1, &OtherMR);
+    if (Err) {
+      char *ErrMsg = LLVMGetErrorMessage(Err);
+      fprintf(stderr, "Error: %s\n", ErrMsg);
+      LLVMDisposeErrorMessage(ErrMsg);
+      LLVMOrcMaterializationResponsibilityFailMaterialization(MR);
+      LLVMOrcDisposeMaterializationResponsibility(MR);
+      return;
+    }
+  }
+  assert(OtherMR);
+
+  LLVMJITCSymbolMapPair OtherPair = {OtherSymbol, Sym};
+  LLVMOrcMaterializationUnitRef OtherMU = LLVMOrcAbsoluteSymbols(&OtherPair, 1);
+  LLVMOrcMaterializationResponsibilityReplace(OtherMR, OtherMU);
+  // OtherSymbol is no longer owned by us
+
+  // FIXME: Implement async lookup
+  // 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.
+
+  LLVMOrcRetainSymbolStringPoolEntry(TargetSym.Name);
+  LLVMOrcRetainSymbolStringPoolEntry(DependencySymbol);
+  LLVMOrcCDependenceMapPair Dependency = {JD, {&DependencySymbol, 1}};
+  LLVMOrcMaterializationResponsibilityAddDependencies(MR, TargetSym.Name,
+                                                      &Dependency, 1);
+
+  LLVMOrcRetainSymbolStringPoolEntry(DependencySymbol);
+  LLVMOrcMaterializationResponsibilityAddDependenciesForAll(MR, &Dependency, 1);
+
+  // See FIXME above
+  LLVMJITCSymbolMapPair Pair = {DependencySymbol, Sym};
+  LLVMOrcMaterializationResponsibilityNotifyResolved(MR, &Pair, 1);
+  // DependencySymbol no longer owned by us
+
+  Pair = {TargetSym.Name, Sym};
+  LLVMOrcMaterializationResponsibilityNotifyResolved(MR, &Pair, 1);
+
+  LLVMOrcMaterializationResponsibilityNotifyEmitted(MR);
+  LLVMOrcDisposeMaterializationResponsibility(MR);
+  return;
+}
+
+TEST_F(OrcCAPITestBase, MaterializationResponsibility) {
+  LLVMJITSymbolFlags Flags = {
+      LLVMJITSymbolGenericFlagsExported | LLVMJITSymbolGenericFlagsCallable, 0};
+  LLVMOrcCSymbolFlagsMapPair Sym = {LLVMOrcLLJITMangleAndIntern(Jit, "foo"),
+                                    Flags};
+
+  LLVMOrcMaterializationUnitRef MU = LLVMOrcCreateCustomMaterializationUnit(
+      "MU", (void *)Jit, &Sym, 1, NULL, &Materialize, NULL, &Destroy);
+  LLVMOrcJITDylibRef JD = LLVMOrcLLJITGetMainJITDylib(Jit);
+  LLVMOrcJITDylibDefine(JD, MU);
+
+  LLVMOrcJITTargetAddress Addr;
+  if (LLVMErrorRef Err = LLVMOrcLLJITLookup(Jit, &Addr, "foo")) {
+    FAIL() << "foo was not materialized " << toString(Err);
+  }
+  ASSERT_TRUE(!!Addr);
+  ASSERT_EQ(Addr, (LLVMOrcJITTargetAddress)&TargetFn);
+
+  if (LLVMErrorRef Err = LLVMOrcLLJITLookup(Jit, &Addr, "other")) {
+    FAIL() << "other was not materialized " << toString(Err);
+  }
+  ASSERT_TRUE(!!Addr);
+  ASSERT_EQ(Addr, (LLVMOrcJITTargetAddress)&TargetFn);
+
+  if (LLVMErrorRef Err = LLVMOrcLLJITLookup(Jit, &Addr, "dependency")) {
+    FAIL() << "dependency was not materialized " << toString(Err);
+  }
+  ASSERT_TRUE(!!Addr);
+  ASSERT_EQ(Addr, (LLVMOrcJITTargetAddress)&TargetFn);
+}