diff --git a/compiler/src/iree/compiler/Codegen/LLVMCPU/ConvertToLLVM.cpp b/compiler/src/iree/compiler/Codegen/LLVMCPU/ConvertToLLVM.cpp
index 8816913..3fb5be6 100644
--- a/compiler/src/iree/compiler/Codegen/LLVMCPU/ConvertToLLVM.cpp
+++ b/compiler/src/iree/compiler/Codegen/LLVMCPU/ConvertToLLVM.cpp
@@ -101,7 +101,8 @@
   enum class EnvironmentField {
     constants,
     import_thunk,
-    imports,
+    import_funcs,
+    import_contexts,
     processor,
   };
 
@@ -124,13 +125,16 @@
     fieldTypes.push_back(uint32PtrType);
 
     // iree_hal_executable_import_thunk_v0_t import_thunk;
-    // const iree_hal_executable_import_v0_t* imports;
-    auto importType = LLVM::LLVMFunctionType::get(uint32Type, int8PtrType);
+    // const iree_hal_executable_import_v0_t* import_funcs;
+    // const void** import_contexts;
+    auto importType = LLVM::LLVMFunctionType::get(
+        uint32Type, {int8PtrType, int8PtrType, int8PtrType});
     auto importPtrType = LLVM::LLVMPointerType::get(importType);
-    auto importThunkType =
-        LLVM::LLVMFunctionType::get(uint32Type, {importPtrType, int8PtrType});
+    auto importThunkType = LLVM::LLVMFunctionType::get(
+        uint32Type, {importPtrType, int8PtrType, int8PtrType, int8PtrType});
     fieldTypes.push_back(LLVM::LLVMPointerType::get(importThunkType));
     fieldTypes.push_back(LLVM::LLVMPointerType::get(importPtrType));
+    fieldTypes.push_back(LLVM::LLVMPointerType::get(int8PtrType));
 
     // iree_hal_processor_v0_t processor;
     fieldTypes.push_back(processorType);
@@ -515,27 +519,35 @@
 
   // Loads the import function pointer of the import |ordinal|.
   // Equivalent to:
-  //   iree_hal_executable_import_v0_t func_ptr = state->imports[ordinal];
-  Value loadImportFuncPtr(Location loc, int64_t ordinal, OpBuilder &builder) {
-    auto importsPtrValue =
-        loadFieldValue(loc, EnvironmentField::imports, builder);
+  //   iree_hal_executable_import_v0_t fn_ptr = state->import_funcs[ordinal];
+  //   void* context = state->import_contexts[ordinal];
+  std::pair<Value, Value> loadImportFunc(Location loc, int64_t ordinal,
+                                         OpBuilder &builder) {
     auto ordinalValue = getIndexValue(loc, ordinal, builder);
-    auto elementPtrValue = builder.createOrFold<LLVM::GEPOp>(
-        loc, importsPtrValue.getType(), importsPtrValue, ordinalValue);
-    return builder.createOrFold<LLVM::LoadOp>(loc, elementPtrValue);
+    auto funcPtrsValue =
+        loadFieldValue(loc, EnvironmentField::import_funcs, builder);
+    auto funcPtrValue = builder.createOrFold<LLVM::GEPOp>(
+        loc, funcPtrsValue.getType(), funcPtrsValue, ordinalValue);
+    auto contextPtrsValue =
+        loadFieldValue(loc, EnvironmentField::import_contexts, builder);
+    auto contextPtrValue = builder.createOrFold<LLVM::GEPOp>(
+        loc, contextPtrsValue.getType(), contextPtrsValue, ordinalValue);
+    return std::make_pair(
+        builder.createOrFold<LLVM::LoadOp>(loc, funcPtrValue),
+        builder.createOrFold<LLVM::LoadOp>(loc, contextPtrValue));
   }
 
   // Returns an i1 indicating whether the optional import with |ordinal| is
   // defined. Equivalent to:
-  //   state->imports[ordinal] != NULL
+  //   state->import_funcs[ordinal] != NULL
   Value isImportFuncAvailable(Location loc, int64_t ordinal,
                               OpBuilder &builder) {
-    auto importPtrValue = loadImportFuncPtr(loc, ordinal, builder);
-    auto nullPtrValue =
-        builder.create<LLVM::NullOp>(loc, importPtrValue.getType()).getResult();
+    auto importFunc = loadImportFunc(loc, ordinal, builder);
+    Value nullPtrValue =
+        builder.create<LLVM::NullOp>(loc, importFunc.first.getType());
     return builder.create<LLVM::ICmpOp>(loc, builder.getI1Type(),
-                                        LLVM::ICmpPredicate::ne, importPtrValue,
-                                        nullPtrValue);
+                                        LLVM::ICmpPredicate::ne,
+                                        importFunc.first, nullPtrValue);
   }
 
   // Emits a call to the import with the given |importOrdinal|.
@@ -546,13 +558,17 @@
                    OpBuilder &builder) {
     auto thunkPtrValue =
         loadFieldValue(loc, EnvironmentField::import_thunk, builder);
-    auto importPtrValue = loadImportFuncPtr(loc, importOrdinal, builder);
+    auto importFunc = loadImportFunc(loc, importOrdinal, builder);
+    Value nullPtrValue = builder.create<LLVM::NullOp>(
+        loc, LLVM::LLVMPointerType::get(builder.getI8Type()));
     auto callOp =
         builder.create<LLVM::CallOp>(loc, TypeRange{builder.getI32Type()},
                                      ValueRange{
                                          /*thunk_func_ptr=*/thunkPtrValue,
-                                         /*import_func_ptr=*/importPtrValue,
-                                         /*import_params=*/params,
+                                         /*import_func_ptr=*/importFunc.first,
+                                         /*context=*/importFunc.second,
+                                         /*params=*/params,
+                                         /*reserved=*/nullPtrValue,
                                      });
     return callOp.getResult();
   }
diff --git a/runtime/src/iree/hal/local/executable_library.h b/runtime/src/iree/hal/local/executable_library.h
index 2757726..a9fc3b6 100644
--- a/runtime/src/iree/hal/local/executable_library.h
+++ b/runtime/src/iree/hal/local/executable_library.h
@@ -154,14 +154,16 @@
 // a useful failure though the HAL does not mandate that all overflows are
 // caught and only that they are not harmful - clamping byte ranges and never
 // returning a failure is sufficient.
-typedef int (*iree_hal_executable_import_v0_t)(void* import_params);
+typedef int (*iree_hal_executable_import_v0_t)(void* context, void* params,
+                                               void* reserved);
 
 // A thunk function used to call an import.
 // All imports must be called through this function by passing the import
 // function pointer as the first argument followed by the arguments of the
 // import function itself.
 typedef int (*iree_hal_executable_import_thunk_v0_t)(
-    iree_hal_executable_import_v0_t fn_ptr, void* import_params);
+    iree_hal_executable_import_v0_t fn_ptr, void* context, void* params,
+    void* reserved);
 
 // Declares imports available to the executable library at runtime.
 // To enable linker isolation, ABI shimming, and import multi-versioning we use
@@ -251,7 +253,8 @@
   // Optional imported functions available for use within the executable.
   // Contains one entry per imported function. If an import was marked as weak
   // then the corresponding entry may be NULL.
-  const iree_hal_executable_import_v0_t* imports;
+  const iree_hal_executable_import_v0_t* import_funcs;
+  const void** import_contexts;
 
   // Optional architecture-specific CPU information.
   // In heterogenous processors this may represent any of the subarchitecture
diff --git a/runtime/src/iree/hal/local/executable_loader.c b/runtime/src/iree/hal/local/executable_loader.c
index f0b8c78..d0a8a31 100644
--- a/runtime/src/iree/hal/local/executable_loader.c
+++ b/runtime/src/iree/hal/local/executable_loader.c
@@ -26,9 +26,11 @@
 
 iree_status_t iree_hal_executable_import_provider_resolve(
     const iree_hal_executable_import_provider_t import_provider,
-    iree_string_view_t symbol_name, void** out_fn_ptr) {
+    iree_string_view_t symbol_name, void** out_fn_ptr, void** out_fn_context) {
   IREE_ASSERT_ARGUMENT(out_fn_ptr);
+  IREE_ASSERT_ARGUMENT(out_fn_context);
   *out_fn_ptr = NULL;
+  *out_fn_context = NULL;
 
   // A `?` suffix indicates the symbol is weakly linked and can be NULL.
   bool is_weak = false;
@@ -47,8 +49,8 @@
                             (int)symbol_name.size, symbol_name.data);
   }
 
-  iree_status_t status =
-      import_provider.resolve(import_provider.self, symbol_name, out_fn_ptr);
+  iree_status_t status = import_provider.resolve(
+      import_provider.self, symbol_name, out_fn_ptr, out_fn_context);
   if (!iree_status_is_ok(status) && is_weak) {
     status = iree_status_ignore(status);  // ok to fail on weak symbols
   }
diff --git a/runtime/src/iree/hal/local/executable_loader.h b/runtime/src/iree/hal/local/executable_loader.h
index c7a5967..5a095d9 100644
--- a/runtime/src/iree/hal/local/executable_loader.h
+++ b/runtime/src/iree/hal/local/executable_loader.h
@@ -37,7 +37,8 @@
   // to the function (or its context) in |out_fn_ptr|.
   iree_status_t(IREE_API_PTR* resolve)(void* self,
                                        iree_string_view_t symbol_name,
-                                       void** out_fn_ptr);
+                                       void** out_fn_ptr,
+                                       void** out_fn_context);
 } iree_hal_executable_import_provider_t;
 
 static inline iree_hal_executable_import_provider_t
@@ -63,7 +64,7 @@
 // allowed to be resolved to NULL. Such cases will always return OK.
 iree_status_t iree_hal_executable_import_provider_resolve(
     const iree_hal_executable_import_provider_t import_provider,
-    iree_string_view_t symbol_name, void** out_fn_ptr);
+    iree_string_view_t symbol_name, void** out_fn_ptr, void** out_fn_context);
 
 //===----------------------------------------------------------------------===//
 // iree_hal_executable_loader_t
diff --git a/runtime/src/iree/hal/local/loaders/embedded_elf_loader.c b/runtime/src/iree/hal/local/loaders/embedded_elf_loader.c
index ddcc1f4..2227137 100644
--- a/runtime/src/iree/hal/local/loaders/embedded_elf_loader.c
+++ b/runtime/src/iree/hal/local/loaders/embedded_elf_loader.c
@@ -98,15 +98,22 @@
   // All calls from the loaded ELF route through our thunk function so that we
   // can adapt to ABI differences.
   executable->base.environment.import_thunk =
-      (iree_hal_executable_import_thunk_v0_t)iree_elf_thunk_i_p;
+      (iree_hal_executable_import_thunk_v0_t)iree_elf_call_i_ppp;
 
   // Allocate storage for the imports.
+  // TODO(benvanik): allocate both as one block.
   IREE_RETURN_AND_END_ZONE_IF_ERROR(
-      z0,
-      iree_allocator_malloc(
-          executable->base.host_allocator,
-          import_table->count * sizeof(*executable->base.environment.imports),
-          (void**)&executable->base.environment.imports));
+      z0, iree_allocator_malloc(
+              executable->base.host_allocator,
+              import_table->count *
+                  sizeof(*executable->base.environment.import_funcs),
+              (void**)&executable->base.environment.import_funcs));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_allocator_malloc(
+              executable->base.host_allocator,
+              import_table->count *
+                  sizeof(*executable->base.environment.import_contexts),
+              (void**)&executable->base.environment.import_contexts));
 
   // Try to resolve each import.
   // NOTE: imports are sorted alphabetically and if we cared we could use this
@@ -117,7 +124,8 @@
         z0,
         iree_hal_executable_import_provider_resolve(
             import_provider, iree_make_cstring_view(import_table->symbols[i]),
-            (void**)&executable->base.environment.imports[i]));
+            (void**)&executable->base.environment.import_funcs[i],
+            (void**)&executable->base.environment.import_contexts[i]));
   }
 
   IREE_TRACE_ZONE_END(z0);
@@ -231,9 +239,13 @@
 
   iree_elf_module_deinitialize(&executable->module);
 
-  if (executable->base.environment.imports != NULL) {
+  if (executable->base.environment.import_funcs != NULL) {
     iree_allocator_free(host_allocator,
-                        (void*)executable->base.environment.imports);
+                        (void*)executable->base.environment.import_funcs);
+  }
+  if (executable->base.environment.import_contexts != NULL) {
+    iree_allocator_free(host_allocator,
+                        (void*)executable->base.environment.import_contexts);
   }
 
   iree_hal_local_executable_deinitialize(
diff --git a/runtime/src/iree/hal/local/loaders/system_library_loader.c b/runtime/src/iree/hal/local/loaders/system_library_loader.c
index 14d2c04..6fb73f8 100644
--- a/runtime/src/iree/hal/local/loaders/system_library_loader.c
+++ b/runtime/src/iree/hal/local/loaders/system_library_loader.c
@@ -206,8 +206,9 @@
 }
 
 static int iree_hal_system_executable_import_thunk_v0(
-    iree_hal_executable_import_v0_t fn_ptr, void* import_params) {
-  return fn_ptr(import_params);
+    iree_hal_executable_import_v0_t fn_ptr, void* context, void* params,
+    void* reserved) {
+  return fn_ptr(context, params, reserved);
 }
 
 // Resolves all of the imports declared by the executable using the given
@@ -225,12 +226,19 @@
       iree_hal_system_executable_import_thunk_v0;
 
   // Allocate storage for the imports.
+  // TODO(benvanik): allocate both as one block.
   IREE_RETURN_AND_END_ZONE_IF_ERROR(
-      z0,
-      iree_allocator_malloc(
-          executable->base.host_allocator,
-          import_table->count * sizeof(*executable->base.environment.imports),
-          (void**)&executable->base.environment.imports));
+      z0, iree_allocator_malloc(
+              executable->base.host_allocator,
+              import_table->count *
+                  sizeof(*executable->base.environment.import_funcs),
+              (void**)&executable->base.environment.import_funcs));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_allocator_malloc(
+              executable->base.host_allocator,
+              import_table->count *
+                  sizeof(*executable->base.environment.import_contexts),
+              (void**)&executable->base.environment.import_contexts));
 
   // Try to resolve each import.
   // NOTE: imports are sorted alphabetically and if we cared we could use this
@@ -241,7 +249,8 @@
         z0,
         iree_hal_executable_import_provider_resolve(
             import_provider, iree_make_cstring_view(import_table->symbols[i]),
-            (void**)&executable->base.environment.imports[i]));
+            (void**)&executable->base.environment.import_funcs[i],
+            (void**)&executable->base.environment.import_contexts[i]));
   }
 
   IREE_TRACE_ZONE_END(z0);
@@ -351,9 +360,13 @@
 
   iree_dynamic_library_release(executable->handle);
 
-  if (executable->base.environment.imports != NULL) {
+  if (executable->base.environment.import_funcs != NULL) {
     iree_allocator_free(host_allocator,
-                        (void*)executable->base.environment.imports);
+                        (void*)executable->base.environment.import_funcs);
+  }
+  if (executable->base.environment.import_contexts != NULL) {
+    iree_allocator_free(host_allocator,
+                        (void*)executable->base.environment.import_contexts);
   }
 
   iree_hal_local_executable_deinitialize(