diff --git a/iree/hal/interpreter/BUILD b/iree/hal/interpreter/BUILD
index 97235f6..204eb0a 100644
--- a/iree/hal/interpreter/BUILD
+++ b/iree/hal/interpreter/BUILD
@@ -18,6 +18,7 @@
         "//iree/hal:executable",
         "//iree/hal:executable_cache",
         "//iree/hal:executable_format",
+        "//iree/rt",
     ],
 )
 
@@ -38,13 +39,13 @@
         "//iree/hal:allocator",
         "//iree/hal:buffer_view",
         "//iree/hal:heap_buffer",
+        "//iree/rt",
         "//iree/schemas/bytecode:interpreter_bytecode_v0",
+        "//iree/vm:bytecode_module",
         "//iree/vm:bytecode_reader",
         "//iree/vm:bytecode_tables_interpreter",
         "//iree/vm:bytecode_util",
-        "//iree/vm:function",
         "//iree/vm:opcode_info",
-        "//iree/vm:stack",
         "//iree/vm:type",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:inlined_vector",
@@ -57,16 +58,13 @@
     srcs = ["bytecode_executable.cc"],
     hdrs = ["bytecode_executable.h"],
     deps = [
-        ":interpreter_context",
+        ":interpreter_module",
         "//iree/base:status",
         "//iree/hal:allocator",
         "//iree/hal:executable",
         "//iree/hal:executable_spec",
+        "//iree/rt",
         "//iree/vm:bytecode_tables_interpreter",
-        "//iree/vm:bytecode_validator",
-        "//iree/vm:context",
-        "//iree/vm:module",
-        "//iree/vm:module_printer",
         "@com_google_absl//absl/types:span",
     ],
 )
@@ -116,30 +114,13 @@
         "//iree/base:tracing",
         "//iree/hal:buffer_view",
         "//iree/hal/host:host_local_command_processor",
+        "//iree/rt",
         "@com_google_absl//absl/container:inlined_vector",
         "@com_google_absl//absl/types:span",
     ],
 )
 
 cc_library(
-    name = "interpreter_context",
-    srcs = ["interpreter_context.cc"],
-    hdrs = ["interpreter_context.h"],
-    deps = [
-        ":bytecode_dispatch",
-        ":bytecode_kernels",
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "//iree/hal:allocator",
-        "//iree/hal:buffer_view",
-        "//iree/vm:context",
-        "//iree/vm:function",
-        "//iree/vm:stack",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
     name = "interpreter_device",
     srcs = ["interpreter_device.cc"],
     hdrs = ["interpreter_device.h"],
@@ -159,6 +140,7 @@
         "//iree/hal/host:host_local_allocator",
         "//iree/hal/host:host_submission_queue",
         "//iree/hal/host:inproc_command_buffer",
+        "//iree/rt",
         "@com_google_absl//absl/container:inlined_vector",
         "@com_google_absl//absl/memory",
         "@com_google_absl//absl/types:span",
@@ -187,3 +169,22 @@
     ],
     alwayslink = 1,
 )
+
+cc_library(
+    name = "interpreter_module",
+    srcs = ["interpreter_module.cc"],
+    hdrs = ["interpreter_module.h"],
+    deps = [
+        ":bytecode_dispatch",
+        ":bytecode_kernels",
+        "//iree/base:flatbuffer_util",
+        "//iree/base:status",
+        "//iree/base:tracing",
+        "//iree/hal:allocator",
+        "//iree/hal:buffer_view",
+        "//iree/rt",
+        "//iree/vm:bytecode_module",
+        "//iree/vm:bytecode_tables_interpreter",
+        "@com_google_absl//absl/types:span",
+    ],
+)
diff --git a/iree/hal/interpreter/CMakeLists.txt b/iree/hal/interpreter/CMakeLists.txt
index 5031688..5295105 100644
--- a/iree/hal/interpreter/CMakeLists.txt
+++ b/iree/hal/interpreter/CMakeLists.txt
@@ -75,7 +75,7 @@
     iree::hal::allocator
     iree::hal::executable
     iree::hal::executable_spec
-    iree::hal::interpreter::interpreter_context
+    iree::hal::interpreter::interpreter_module
     iree::vm::bytecode_tables_interpreter
     iree::vm::bytecode_validator
     iree::vm::context
@@ -138,27 +138,6 @@
 
 iree_cc_library(
   NAME
-    interpreter_context
-  HDRS
-    "interpreter_context.h"
-  SRCS
-    "interpreter_context.cc"
-  DEPS
-    absl::span
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::hal::allocator
-    iree::hal::buffer_view
-    iree::hal::interpreter::bytecode_dispatch
-    iree::hal::interpreter::bytecode_kernels
-    iree::vm::context
-    iree::vm::function
-    iree::vm::stack
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
     interpreter_device
   HDRS
     "interpreter_device.h"
@@ -212,3 +191,24 @@
     iree::hal::interpreter::interpreter_driver
   PUBLIC
 )
+
+iree_cc_library(
+  NAME
+    interpreter_module
+  HDRS
+    "interpreter_module.h"
+  SRCS
+    "interpreter_module.cc"
+  DEPS
+    absl::span
+    iree::base::flatbuffer_util
+    iree::base::status
+    iree::hal::allocator
+    iree::hal::buffer_view
+    iree::hal::interpreter::bytecode_dispatch
+    iree::hal::interpreter::bytecode_kernels
+    iree::vm::context
+    iree::vm::function
+    iree::vm::stack
+  PUBLIC
+)
diff --git a/iree/hal/interpreter/bytecode_cache.cc b/iree/hal/interpreter/bytecode_cache.cc
index de7d8f2..b42db5a 100644
--- a/iree/hal/interpreter/bytecode_cache.cc
+++ b/iree/hal/interpreter/bytecode_cache.cc
@@ -23,8 +23,9 @@
 namespace iree {
 namespace hal {
 
-BytecodeCache::BytecodeCache(hal::Allocator* allocator)
-    : allocator_(allocator) {}
+BytecodeCache::BytecodeCache(ref_ptr<rt::Instance> instance,
+                             hal::Allocator* allocator)
+    : instance_(std::move(instance)), allocator_(allocator) {}
 
 BytecodeCache::~BytecodeCache() = default;
 
@@ -43,9 +44,9 @@
   // Wrap the data (or copy it).
   bool allow_aliasing_data =
       AllBitsSet(mode, ExecutableCachingMode::kAliasProvidedData);
-  ASSIGN_OR_RETURN(
-      auto executable,
-      BytecodeExecutable::Load(allocator_, spec, !allow_aliasing_data));
+  ASSIGN_OR_RETURN(auto executable,
+                   BytecodeExecutable::Load(add_ref(instance_), allocator_,
+                                            spec, !allow_aliasing_data));
 
   return executable;
 }
diff --git a/iree/hal/interpreter/bytecode_cache.h b/iree/hal/interpreter/bytecode_cache.h
index fd955c5..4da59ec 100644
--- a/iree/hal/interpreter/bytecode_cache.h
+++ b/iree/hal/interpreter/bytecode_cache.h
@@ -18,13 +18,14 @@
 #include "iree/hal/allocator.h"
 #include "iree/hal/executable.h"
 #include "iree/hal/executable_cache.h"
+#include "iree/rt/instance.h"
 
 namespace iree {
 namespace hal {
 
 class BytecodeCache final : public ExecutableCache {
  public:
-  explicit BytecodeCache(hal::Allocator* allocator);
+  BytecodeCache(ref_ptr<rt::Instance> instance, hal::Allocator* allocator);
   ~BytecodeCache() override;
 
   bool CanPrepareFormat(ExecutableFormat format) const override;
@@ -33,6 +34,7 @@
       ExecutableCachingModeBitfield mode, const ExecutableSpec& spec) override;
 
  private:
+  ref_ptr<rt::Instance> instance_;
   hal::Allocator* allocator_;
 };
 
diff --git a/iree/hal/interpreter/bytecode_dispatch.cc b/iree/hal/interpreter/bytecode_dispatch.cc
index b89fb44..f0e7040 100644
--- a/iree/hal/interpreter/bytecode_dispatch.cc
+++ b/iree/hal/interpreter/bytecode_dispatch.cc
@@ -33,11 +33,12 @@
 #include "iree/hal/interpreter/bytecode_dispatch_conversion.h"
 #include "iree/hal/interpreter/bytecode_dispatch_util.h"
 #include "iree/hal/interpreter/bytecode_kernels.h"
+#include "iree/rt/function.h"
 #include "iree/schemas/bytecode/interpreter_bytecode_v0.h"
+#include "iree/vm/bytecode_module.h"
 #include "iree/vm/bytecode_reader.h"
 #include "iree/vm/bytecode_tables_interpreter.h"
 #include "iree/vm/bytecode_util.h"
-#include "iree/vm/function.h"
 #include "iree/vm/opcode_info.h"
 
 namespace iree {
@@ -45,11 +46,9 @@
 
 namespace {
 
+using ::iree::rt::Stack;
+using ::iree::rt::StackFrame;
 using ::iree::vm::BytecodeReader;
-using ::iree::vm::ImportFunction;
-using ::iree::vm::NativeFunction;
-using ::iree::vm::Stack;
-using ::iree::vm::StackFrame;
 
 }  // namespace
 
@@ -111,38 +110,23 @@
   DISPATCH_CORE_OPCODE(kCall, {
     auto* old_stack_frame = stack->current_frame();
     ASSIGN_OR_RETURN(const auto& target_function, reader.ReadFunction());
+    // TODO(benvanik): rework register storage interface.
+    ASSIGN_OR_RETURN(
+        const auto* function_def,
+        static_cast<const vm::BytecodeModule*>(target_function.module())
+            ->GetFunctionDef(target_function.linkage(),
+                             target_function.ordinal()));
     ASSIGN_OR_RETURN(auto* new_stack_frame, stack->PushFrame(target_function));
+    new_stack_frame->mutable_registers()->buffer_views.resize(
+        function_def->bytecode()->local_count());
     RETURN_IF_ERROR(
         reader.CopyInputsAndSwitchStackFrame(old_stack_frame, new_stack_frame));
     DVLOG(1) << "Call; stack now: " << stack->DebugString();
   });
 
   DISPATCH_CORE_OPCODE(kCallImport, {
-    auto* old_stack_frame = stack->current_frame();
-    ASSIGN_OR_RETURN(const auto* target_function, reader.ReadImportFunction());
-    switch (target_function->link_type()) {
-      case ImportFunction::LinkType::kModule: {
-        ASSIGN_OR_RETURN(auto* new_stack_frame,
-                         stack->PushFrame(target_function->linked_function()));
-        RETURN_IF_ERROR(reader.CopyInputsAndSwitchStackFrame(old_stack_frame,
-                                                             new_stack_frame));
-        DVLOG(1) << "Call module import; stack now: " << stack->DebugString();
-        break;
-      }
-      case ImportFunction::LinkType::kNativeFunction: {
-        ASSIGN_OR_RETURN(auto* new_stack_frame,
-                         stack->PushFrame(*target_function));
-        RETURN_IF_ERROR(reader.CopyInputsAndSwitchStackFrame(old_stack_frame,
-                                                             new_stack_frame));
-        DVLOG(1) << "Call native import; stack now: " << stack->DebugString();
-        RETURN_IF_ERROR(CallNativeFunction(stack, *target_function));
-        RETURN_IF_ERROR(reader.CopyResultsAndSwitchStackFrame(old_stack_frame,
-                                                              new_stack_frame));
-        RETURN_IF_ERROR(stack->PopFrame());
-        DVLOG(1) << "Return from native; stack now: " << stack->DebugString();
-        break;
-      }
-    }
+    return UnimplementedErrorBuilder(IREE_LOC)
+           << "Non-module imports not supported";
   });
 
   DISPATCH_CORE_OPCODE(kCallIndirect, {
@@ -156,8 +140,9 @@
       // Returning from entry function. Marshal results from the return stmt.
       ASSIGN_OR_RETURN(int32_t src_count, reader.ReadCount());
       for (int i = 0; i < src_count; ++i) {
-        ASSIGN_OR_RETURN(auto* src_local,
-                         reader.ReadLocal(old_stack_frame->mutable_locals()));
+        ASSIGN_OR_RETURN(
+            auto* src_local,
+            reader.ReadLocal(old_stack_frame->mutable_registers()));
         entry_results[i] = std::move(*src_local);
       }
       DVLOG(1) << "Returning to entry";
diff --git a/iree/hal/interpreter/bytecode_dispatch.h b/iree/hal/interpreter/bytecode_dispatch.h
index 1d4b7d1..edd92d2 100644
--- a/iree/hal/interpreter/bytecode_dispatch.h
+++ b/iree/hal/interpreter/bytecode_dispatch.h
@@ -18,15 +18,15 @@
 #include "iree/base/status.h"
 #include "iree/hal/allocator.h"
 #include "iree/hal/interpreter/bytecode_kernels.h"
-#include "iree/vm/stack.h"
-#include "iree/vm/stack_frame.h"
+#include "iree/rt/stack.h"
+#include "iree/rt/stack_frame.h"
 
 namespace iree {
 namespace hal {
 
 Status Dispatch(hal::Allocator* allocator,
-                kernels::RuntimeState* kernel_runtime_state, vm::Stack* stack,
-                vm::StackFrame* entry_stack_frame,
+                kernels::RuntimeState* kernel_runtime_state, rt::Stack* stack,
+                rt::StackFrame* entry_stack_frame,
                 absl::Span<BufferView> entry_results);
 
 }  // namespace hal
diff --git a/iree/hal/interpreter/bytecode_dispatch_util.cc b/iree/hal/interpreter/bytecode_dispatch_util.cc
index 0e59bd8..40937e1 100644
--- a/iree/hal/interpreter/bytecode_dispatch_util.cc
+++ b/iree/hal/interpreter/bytecode_dispatch_util.cc
@@ -34,18 +34,6 @@
   return false;
 }
 
-Status CallNativeFunction(vm::Stack* stack,
-                          const vm::ImportFunction& function) {
-  auto* stack_frame = stack->current_frame();
-
-  // Marshal inputs and outputs.
-  auto args = stack_frame->mutable_locals().subspan(0, function.input_count());
-  auto results = stack_frame->mutable_locals().subspan(args.size());
-
-  const auto& fn = function.native_function();
-  return fn(stack, args, results);
-}
-
 Status ValidateElementwiseUnaryOp(BufferView* src_local,
                                   BufferView* dst_local) {
   // TODO(benvanik): validate shapes.
diff --git a/iree/hal/interpreter/bytecode_dispatch_util.h b/iree/hal/interpreter/bytecode_dispatch_util.h
index b8f40e1..cb8d7d9 100644
--- a/iree/hal/interpreter/bytecode_dispatch_util.h
+++ b/iree/hal/interpreter/bytecode_dispatch_util.h
@@ -24,10 +24,10 @@
 #include "iree/hal/buffer_view.h"
 #include "iree/hal/heap_buffer.h"
 #include "iree/hal/interpreter/bytecode_kernels.h"
+#include "iree/rt/function.h"
+#include "iree/rt/stack.h"
 #include "iree/schemas/bytecode/interpreter_bytecode_v0.h"
 #include "iree/vm/bytecode_reader.h"
-#include "iree/vm/function.h"
-#include "iree/vm/stack.h"
 #include "iree/vm/type.h"
 
 // TODO(benvanik): move to dedicated config file/build flags.
@@ -42,8 +42,6 @@
 // bitwise zero.
 bool BufferViewIsTrue(const BufferView& buffer_view);
 
-Status CallNativeFunction(vm::Stack* stack, const vm::ImportFunction& function);
-
 Status ValidateElementwiseUnaryOp(BufferView* src_local, BufferView* dst_local);
 Status ValidateElementwiseBinaryOp(BufferView* lhs_local, BufferView* rhs_local,
                                    BufferView* dst_local);
diff --git a/iree/hal/interpreter/bytecode_executable.cc b/iree/hal/interpreter/bytecode_executable.cc
index 130eb77..c528263 100644
--- a/iree/hal/interpreter/bytecode_executable.cc
+++ b/iree/hal/interpreter/bytecode_executable.cc
@@ -16,63 +16,40 @@
 
 #include <iostream>
 
-#include "iree/vm/bytecode_tables_interpreter.h"
-#include "iree/vm/bytecode_validator.h"
-#include "iree/vm/module.h"
-#include "iree/vm/module_printer.h"
+#include "iree/hal/interpreter/interpreter_module.h"
+#include "iree/rt/policy.h"
 
 namespace iree {
 namespace hal {
 
-namespace {
-// TODO(benvanik): remove when debugger is wired up to the HAL.
-const bool kEnableExecutablePrinting = false;
-}  // namespace
-
 // static
 StatusOr<ref_ptr<BytecodeExecutable>> BytecodeExecutable::Load(
-    hal::Allocator* allocator, ExecutableSpec spec, bool allow_aliasing_data) {
+    ref_ptr<rt::Instance> instance, hal::Allocator* allocator,
+    ExecutableSpec spec, bool allow_aliasing_data) {
   // Allocate the executable now.
   // We do this here so that if we need to clone the data we are passing that
   // to the VM loader instead of the data we may not have access to later.
-  auto executable =
-      make_ref<BytecodeExecutable>(allocator, spec, allow_aliasing_data);
-  auto* context = executable->mutable_context();
+  auto executable = make_ref<BytecodeExecutable>(std::move(instance), allocator,
+                                                 spec, allow_aliasing_data);
 
   // Create the executable module.
   auto module_def =
       ::flatbuffers::GetRoot<ModuleDef>(executable->executable_data().data());
-  ASSIGN_OR_RETURN(auto module, vm::Module::FromDef(*module_def));
-  executable->module_ = module.get();
-  RETURN_IF_ERROR(context->RegisterModule(std::move(module)));
-
-  // Validate bytecode to ensure it will be usable for execution.
-  // We do this here so that we get a good stack immediately when the bytecode
-  // is provided instead of when we go to run it. This more closely mirrors how
-  // a backend that performed compilation (such as SPIR-V) would fail.
-  for (auto* function_def :
-       *executable->module().function_table().def().functions()) {
-    RETURN_IF_ERROR(vm::BytecodeValidator::Validate(
-        *context, executable->module(), *function_def->bytecode()));
-  }
-
-  // Print the bytecode.
-  // TODO(benvanik): remove when debugger is wired up to the HAL.
-  if (kEnableExecutablePrinting) {
-    vm::PrintModuleFlagBitfield print_flags = vm::PrintModuleFlag::kNone;
-    for (const auto& module : context->modules()) {
-      RETURN_IF_ERROR(vm::PrintModuleToStream(
-          vm::interpreter_opcode_table(), *module, print_flags, &std::cout));
-    }
-  }
+  ASSIGN_OR_RETURN(auto module,
+                   InterpreterModule::FromDef(allocator, *module_def));
+  executable->module_ = add_ref(module);
+  RETURN_IF_ERROR(executable->context()->RegisterModule(std::move(module)));
 
   return executable;
 }
 
-BytecodeExecutable::BytecodeExecutable(hal::Allocator* allocator,
+BytecodeExecutable::BytecodeExecutable(ref_ptr<rt::Instance> instance,
+                                       hal::Allocator* allocator,
                                        ExecutableSpec spec,
                                        bool allow_aliasing_data)
-    : spec_(spec), context_(allocator) {
+    : spec_(spec),
+      context_(
+          make_ref<rt::Context>(std::move(instance), make_ref<rt::Policy>())) {
   if (!allow_aliasing_data) {
     // Clone data.
     cloned_executable_data_ = {spec.executable_data.begin(),
diff --git a/iree/hal/interpreter/bytecode_executable.h b/iree/hal/interpreter/bytecode_executable.h
index 1fae48f..6cd47de 100644
--- a/iree/hal/interpreter/bytecode_executable.h
+++ b/iree/hal/interpreter/bytecode_executable.h
@@ -22,20 +22,21 @@
 #include "iree/hal/allocator.h"
 #include "iree/hal/executable.h"
 #include "iree/hal/executable_spec.h"
-#include "iree/hal/interpreter/interpreter_context.h"
-#include "iree/vm/context.h"
+#include "iree/rt/context.h"
+#include "iree/rt/instance.h"
+#include "iree/rt/module.h"
 
 namespace iree {
 namespace hal {
 
 class BytecodeExecutable final : public Executable {
  public:
-  static StatusOr<ref_ptr<BytecodeExecutable>> Load(hal::Allocator* allocator,
-                                                    ExecutableSpec spec,
-                                                    bool allow_aliasing_data);
+  static StatusOr<ref_ptr<BytecodeExecutable>> Load(
+      ref_ptr<rt::Instance> instance, hal::Allocator* allocator,
+      ExecutableSpec spec, bool allow_aliasing_data);
 
-  BytecodeExecutable(hal::Allocator* allocator, ExecutableSpec spec,
-                     bool allow_aliasing_data);
+  BytecodeExecutable(ref_ptr<rt::Instance> instance, hal::Allocator* allocator,
+                     ExecutableSpec spec, bool allow_aliasing_data);
   ~BytecodeExecutable() override;
 
   bool supports_debugging() const override { return false; }
@@ -46,20 +47,19 @@
   }
 
   // VM context with the executable registered.
-  const InterpreterContext& context() const { return context_; }
-  InterpreterContext* mutable_context() { return &context_; }
+  const ref_ptr<rt::Context>& context() const { return context_; }
 
   // VM module representing the executable.
   // Note that there may be more than one module in the Context and only this
   // module can be used to lookup executable exports.
-  const vm::Module& module() const { return *module_; }
+  const ref_ptr<rt::Module>& module() const { return module_; }
 
  private:
   ExecutableSpec spec_;
   std::vector<uint8_t> cloned_executable_data_;
 
-  InterpreterContext context_;
-  vm::Module* module_ = nullptr;
+  ref_ptr<rt::Context> context_;
+  ref_ptr<rt::Module> module_;
 };
 
 }  // namespace hal
diff --git a/iree/hal/interpreter/interpreter_command_processor.cc b/iree/hal/interpreter/interpreter_command_processor.cc
index a79b10e..783809d 100644
--- a/iree/hal/interpreter/interpreter_command_processor.cc
+++ b/iree/hal/interpreter/interpreter_command_processor.cc
@@ -21,6 +21,7 @@
 #include "iree/base/tracing.h"
 #include "iree/hal/buffer_view.h"
 #include "iree/hal/interpreter/bytecode_executable.h"
+#include "iree/rt/stack.h"
 
 namespace iree {
 namespace hal {
@@ -40,26 +41,23 @@
   auto* executable =
       static_cast<BytecodeExecutable*>(dispatch_request.executable);
   const auto& module = executable->module();
-  ASSIGN_OR_RETURN(auto entry_function, module.function_table().LookupExport(
+  ASSIGN_OR_RETURN(auto entry_function, module->LookupFunctionByOrdinal(
+                                            rt::Function::Linkage::kExport,
                                             dispatch_request.entry_point));
 
-  vm::Stack stack;
+  rt::Stack stack(executable->context().get());
 
   // TODO(benvanik): avoid this by directly referencing the bindings.
-  absl::InlinedVector<BufferView, 8> args;
-  args.reserve(dispatch_request.bindings.size());
+  absl::InlinedVector<BufferView, 8> arguments;
+  arguments.reserve(dispatch_request.bindings.size());
   for (auto& binding : dispatch_request.bindings) {
-    args.push_back(BufferView{add_ref(binding.buffer), binding.shape,
-                              binding.element_size});
+    arguments.push_back(BufferView{add_ref(binding.buffer), binding.shape,
+                                   binding.element_size});
   }
   absl::InlinedVector<BufferView, 8> results;
-  if (entry_function.result_count() > 0) {
-    return UnimplementedErrorBuilder(IREE_LOC)
-           << "Executable export results are not yet implemented";
-  }
 
-  RETURN_IF_ERROR(executable->context().Invoke(
-      &stack, entry_function, absl::MakeSpan(args), absl::MakeSpan(results)));
+  RETURN_IF_ERROR(executable->module()->Execute(
+      &stack, entry_function, std::move(arguments), &results));
 
   return OkStatus();
 }
diff --git a/iree/hal/interpreter/interpreter_context.cc b/iree/hal/interpreter/interpreter_context.cc
deleted file mode 100644
index e30aa96..0000000
--- a/iree/hal/interpreter/interpreter_context.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/hal/interpreter/interpreter_context.h"
-
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-#include "iree/hal/interpreter/bytecode_dispatch.h"
-
-namespace iree {
-namespace hal {
-
-namespace {
-
-using ::iree::vm::Function;
-
-}  // namespace
-
-Status InterpreterContext::Invoke(vm::Stack* stack, Function function,
-                                  absl::Span<BufferView> args,
-                                  absl::Span<BufferView> results) const {
-  // Verify arg/result counts.
-  if (args.size() != function.input_count()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function " << function.name() << " requires "
-           << function.input_count() << " inputs but only " << args.size()
-           << " provided";
-  }
-  if (results.size() != function.result_count()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function " << function.name() << " requires "
-           << function.result_count() << " outputs but only " << results.size()
-           << " provided";
-  }
-
-  // Push stack frame for the function we are calling.
-  ASSIGN_OR_RETURN(auto* callee_stack_frame, stack->PushFrame(function));
-
-  // Marshal input arguments.
-  for (int i = 0; i < args.size(); ++i) {
-    *callee_stack_frame->mutable_local(i) = std::move(args[i]);
-  }
-
-  // Run main dispatch loop until it exits (or errors).
-  RETURN_IF_ERROR(Dispatch(allocator_, &kernel_runtime_state_, stack,
-                           callee_stack_frame, results));
-
-  // Pop the callee frame to balance out the stack.
-  RETURN_IF_ERROR(stack->PopFrame());
-
-  return OkStatus();
-}
-
-}  // namespace hal
-}  // namespace iree
diff --git a/iree/hal/interpreter/interpreter_context.h b/iree/hal/interpreter/interpreter_context.h
deleted file mode 100644
index 2808c14..0000000
--- a/iree/hal/interpreter/interpreter_context.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_HAL_INTERPRETER_INTERPRETER_CONTEXT_H_
-#define IREE_HAL_INTERPRETER_INTERPRETER_CONTEXT_H_
-
-#include <memory>
-
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/hal/allocator.h"
-#include "iree/hal/buffer_view.h"
-#include "iree/hal/interpreter/bytecode_kernels.h"
-#include "iree/vm/context.h"
-#include "iree/vm/function.h"
-#include "iree/vm/stack.h"
-
-namespace iree {
-namespace hal {
-
-class InterpreterContext final : public vm::Context {
- public:
-  explicit InterpreterContext(hal::Allocator* allocator)
-      : allocator_(allocator) {}
-
-  // TODO(benvanik): helpers to make passing args easier
-  Status Invoke(vm::Stack* stack, vm::Function function,
-                absl::Span<BufferView> args,
-                absl::Span<BufferView> results) const;
-
- private:
-  hal::Allocator* allocator_;
-  mutable kernels::RuntimeState kernel_runtime_state_;
-};
-
-}  // namespace hal
-}  // namespace iree
-
-#endif  // IREE_HAL_INTERPRETER_INTERPRETER_CONTEXT_H_
diff --git a/iree/hal/interpreter/interpreter_device.cc b/iree/hal/interpreter/interpreter_device.cc
index 239084e..7a61cc3 100644
--- a/iree/hal/interpreter/interpreter_device.cc
+++ b/iree/hal/interpreter/interpreter_device.cc
@@ -97,11 +97,12 @@
 }  // namespace
 
 InterpreterDevice::InterpreterDevice(DeviceInfo device_info)
-    : Device(std::move(device_info)) {
+    : Device(std::move(device_info)), instance_(make_ref<rt::Instance>()) {
   // We currently only expose a single command queue.
   auto command_queue = absl::make_unique<UnsynchronizedCommandQueue>(
       &allocator_, "cpu0",
       CommandCategory::kTransfer | CommandCategory::kDispatch);
+
   // TODO(benvanik): allow injection of the wrapper type to support
   // SyncCommandQueue without always linking in both.
   auto async_command_queue =
@@ -112,7 +113,7 @@
 InterpreterDevice::~InterpreterDevice() = default;
 
 std::shared_ptr<ExecutableCache> InterpreterDevice::CreateExecutableCache() {
-  return std::make_shared<BytecodeCache>(&allocator_);
+  return std::make_shared<BytecodeCache>(add_ref(instance_), &allocator_);
 }
 
 StatusOr<ref_ptr<CommandBuffer>> InterpreterDevice::CreateCommandBuffer(
diff --git a/iree/hal/interpreter/interpreter_device.h b/iree/hal/interpreter/interpreter_device.h
index 9afdaac..5987ab9 100644
--- a/iree/hal/interpreter/interpreter_device.h
+++ b/iree/hal/interpreter/interpreter_device.h
@@ -21,6 +21,7 @@
 #include "iree/hal/device.h"
 #include "iree/hal/host/host_local_allocator.h"
 #include "iree/hal/interpreter/bytecode_kernels.h"
+#include "iree/rt/instance.h"
 
 namespace iree {
 namespace hal {
@@ -66,6 +67,7 @@
   Status WaitIdle(absl::Time deadline) override;
 
  private:
+  ref_ptr<rt::Instance> instance_;
   kernels::RuntimeState kernel_runtime_state_;
   mutable HostLocalAllocator allocator_;
   mutable absl::InlinedVector<std::unique_ptr<CommandQueue>, 1> command_queues_;
diff --git a/iree/hal/interpreter/interpreter_module.cc b/iree/hal/interpreter/interpreter_module.cc
new file mode 100644
index 0000000..c569fea
--- /dev/null
+++ b/iree/hal/interpreter/interpreter_module.cc
@@ -0,0 +1,80 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "iree/hal/interpreter/interpreter_module.h"
+
+#include "iree/base/flatbuffer_util.h"
+#include "iree/base/status.h"
+#include "iree/base/tracing.h"
+#include "iree/hal/interpreter/bytecode_dispatch.h"
+#include "iree/vm/bytecode_tables_interpreter.h"
+
+namespace iree {
+namespace hal {
+
+// static
+StatusOr<ref_ptr<rt::Module>> InterpreterModule::FromDef(
+    hal::Allocator* allocator, const ModuleDef& module_def) {
+  ASSIGN_OR_RETURN(auto module_file,
+                   vm::ModuleFile::Create(&module_def, []() {}));
+  if (module_file->root() == nullptr) {
+    return InvalidArgumentErrorBuilder(IREE_LOC) << "No root ModuleDef present";
+  }
+
+  auto module =
+      assign_ref(new InterpreterModule(allocator, std::move(module_file)));
+
+  // TODO(benvanik): validate internals here? or make explicit?
+
+  return {std::move(module)};
+}
+
+InterpreterModule::InterpreterModule(
+    hal::Allocator* allocator, std::unique_ptr<vm::ModuleFile> module_file)
+    : vm::BytecodeModule(std::move(module_file),
+                         vm::interpreter_opcode_table()),
+      allocator_(allocator) {}
+
+Status InterpreterModule::Execute(
+    rt::Stack* stack, const rt::Function function,
+    absl::InlinedVector<hal::BufferView, 8> arguments,
+    absl::InlinedVector<hal::BufferView, 8>* results) const {
+  IREE_TRACE_SCOPE0("InterperterModule::Execute");
+
+  // Push stack frame for the function we are calling.
+  ASSIGN_OR_RETURN(auto* callee_stack_frame, stack->PushFrame(function));
+
+  // TODO(benvanik): rework register storage interface.
+  ASSIGN_OR_RETURN(const auto* function_def,
+                   GetFunctionDef(function.linkage(), function.ordinal()));
+  auto* registers = callee_stack_frame->mutable_registers();
+  registers->buffer_views.resize(function_def->bytecode()->local_count());
+
+  // Marshal input arguments.
+  for (int i = 0; i < arguments.size(); ++i) {
+    registers->buffer_views[i] = std::move(arguments[i]);
+  }
+
+  // Run main dispatch loop until it exits (or errors).
+  RETURN_IF_ERROR(Dispatch(allocator_, &kernel_runtime_state_, stack,
+                           callee_stack_frame, results));
+
+  // Pop the callee frame to balance out the stack.
+  RETURN_IF_ERROR(stack->PopFrame());
+
+  return OkStatus();
+}
+
+}  // namespace hal
+}  // namespace iree
diff --git a/iree/hal/interpreter/interpreter_module.h b/iree/hal/interpreter/interpreter_module.h
new file mode 100644
index 0000000..d7d98e3
--- /dev/null
+++ b/iree/hal/interpreter/interpreter_module.h
@@ -0,0 +1,55 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_HAL_INTERPRETER_INTERPRETER_MODULE_H_
+#define IREE_HAL_INTERPRETER_INTERPRETER_MODULE_H_
+
+#include <memory>
+
+#include "absl/types/span.h"
+#include "iree/base/status.h"
+#include "iree/hal/allocator.h"
+#include "iree/hal/buffer_view.h"
+#include "iree/hal/interpreter/bytecode_kernels.h"
+#include "iree/rt/function.h"
+#include "iree/rt/module.h"
+#include "iree/rt/stack.h"
+#include "iree/vm/bytecode_module.h"
+#include "iree/vm/bytecode_tables_interpreter.h"
+
+namespace iree {
+namespace hal {
+
+class InterpreterModule final : public vm::BytecodeModule {
+ public:
+  static StatusOr<ref_ptr<rt::Module>> FromDef(hal::Allocator* allocator,
+                                               const ModuleDef& module_def);
+
+  Status Execute(
+      rt::Stack* stack, const rt::Function function,
+      absl::InlinedVector<hal::BufferView, 8> arguments,
+      absl::InlinedVector<hal::BufferView, 8>* results) const override;
+
+ private:
+  InterpreterModule(hal::Allocator* allocator,
+                    std::unique_ptr<vm::ModuleFile> module_file);
+
+  hal::Allocator* allocator_;
+  mutable kernels::RuntimeState kernel_runtime_state_;
+};
+
+}  // namespace hal
+}  // namespace iree
+
+#endif  // IREE_HAL_INTERPRETER_INTERPRETER_MODULE_H_
diff --git a/iree/rt/BUILD b/iree/rt/BUILD
index 8fc7242..65e956b 100644
--- a/iree/rt/BUILD
+++ b/iree/rt/BUILD
@@ -39,25 +39,31 @@
         "function.cc",
         "instance.cc",
         "invocation.cc",
+        "module_printer.cc",
         "source_location.cc",
+        "stack.cc",
         "stack_frame.cc",
         "stack_trace.cc",
     ],
     hdrs = [
         "context.h",
+        "disassembler.h",
         "function.h",
         "function_signature.h",
         "instance.h",
         "invocation.h",
         "module.h",
+        "module_printer.h",
         "module_signature.h",
         "policy.h",
         "source_location.h",
         "source_resolver.h",
+        "stack.h",
         "stack_frame.h",
         "stack_trace.h",
     ],
     deps = [
+        "//iree/base:bitfield",
         "//iree/base:intrusive_list",
         "//iree/base:ref_ptr",
         "//iree/base:status",
diff --git a/iree/rt/CMakeLists.txt b/iree/rt/CMakeLists.txt
index 8cf7786..61b14a3 100644
--- a/iree/rt/CMakeLists.txt
+++ b/iree/rt/CMakeLists.txt
@@ -40,20 +40,25 @@
     "function.cc"
     "instance.cc"
     "invocation.cc"
+    "module_printer.cc"
     "source_location.cc"
+    "stack.cc"
     "stack_frame.cc"
     "stack_trace.cc"
   HDRS
     "context.h"
+    "disassembler.h"
     "function.h"
     "function_signature.h"
     "instance.h"
     "invocation.h"
     "module.h"
+    "module_printer.h"
     "module_signature.h"
     "policy.h"
     "source_location.h"
     "source_resolver.h"
+    "stack.h"
     "stack_frame.h"
     "stack_trace.h"
   DEPS
@@ -64,6 +69,7 @@
     absl::time
     absl::optional
     absl::span
+    iree::base::bitfield
     iree::base::intrusive_list
     iree::base::ref_ptr
     iree::base::status
diff --git a/iree/rt/api.cc b/iree/rt/api.cc
index 6e1e5c5..db43358 100644
--- a/iree/rt/api.cc
+++ b/iree/rt/api.cc
@@ -108,6 +108,8 @@
 
   SourceResolver* source_resolver() const override { return nullptr; }
 
+  Disassembler* disassembler() const override { return nullptr; }
+
   std::string DebugStringShort() const override { return std::string(name()); }
 
   StatusOr<const Function> LookupFunctionByOrdinal(
@@ -165,7 +167,7 @@
   }
 
   Status Execute(
-      const Function function,
+      Stack* stack, const Function function,
       absl::InlinedVector<hal::BufferView, 8> arguments,
       absl::InlinedVector<hal::BufferView, 8>* results) const override {
     // TODO(benvanik): fn ptr callback to external code. Waiting on fibers.
diff --git a/iree/rt/context.cc b/iree/rt/context.cc
index ba49cc4..6320325 100644
--- a/iree/rt/context.cc
+++ b/iree/rt/context.cc
@@ -123,6 +123,24 @@
                                       function_name);
 }
 
+StatusOr<const Function> Context::ResolveImport(const Module* module,
+                                                int32_t ordinal) const {
+  for (const auto& import_table_ref : module_import_tables_) {
+    if (import_table_ref.first == module) {
+      const auto& import_table = import_table_ref.second;
+      if (ordinal >= import_table.size()) {
+        return NotFoundErrorBuilder(IREE_LOC)
+               << "Import ordinal " << ordinal
+               << " out of bounds of import table (" << import_table.size()
+               << ")";
+      }
+      return import_table[ordinal];
+    }
+  }
+  return NotFoundErrorBuilder(IREE_LOC)
+         << "Import ordinal " << ordinal << " not found";
+}
+
 void Context::RegisterInvocation(Invocation* invocation) {
   {
     absl::MutexLock lock(&invocations_mutex_);
diff --git a/iree/rt/context.h b/iree/rt/context.h
index 83b7ee4..d67b79a 100644
--- a/iree/rt/context.h
+++ b/iree/rt/context.h
@@ -80,6 +80,11 @@
   // reference is valid for the lifetime of the context.
   StatusOr<const Function> ResolveFunction(absl::string_view full_name) const;
 
+  // Resolves an imported function by import ordinal. The function reference is
+  // valid for the lifetime of the context.
+  StatusOr<const Function> ResolveImport(const Module* module,
+                                         int32_t ordinal) const;
+
  private:
   // Resolves imports for the given module.
   StatusOr<ModuleImportTable> ResolveImports(Module* module);
diff --git a/iree/rt/disassembler.h b/iree/rt/disassembler.h
new file mode 100644
index 0000000..52d91ee
--- /dev/null
+++ b/iree/rt/disassembler.h
@@ -0,0 +1,64 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_RT_DISASSEMBLER_H_
+#define IREE_RT_DISASSEMBLER_H_
+
+#include <cstdint>
+#include <ostream>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "iree/base/status.h"
+#include "iree/rt/function.h"
+#include "iree/rt/source_location.h"
+
+namespace iree {
+namespace rt {
+
+// A single disassembled instruction.
+struct Instruction {
+  // Offset of the instruction within the function.
+  // The meaning of this is backend-dependent.
+  SourceOffset offset;
+
+  // The first line of |long_text|.
+  absl::string_view short_text;
+
+  // Human-readable text of the instruction. May contain multiple lines.
+  std::string long_text;
+};
+
+// Disassembles functions into instructions.
+//
+// Thread-safe.
+class Disassembler {
+ public:
+  virtual ~Disassembler() = default;
+
+  // Disassembles one or more instructions within the given function based on
+  // source offsets.
+  virtual StatusOr<std::vector<Instruction>> DisassembleInstructions(
+      const Function& function, SourceOffset offset,
+      int32_t instruction_count = INT32_MAX) const = 0;
+
+ protected:
+  Disassembler() = default;
+};
+
+}  // namespace rt
+}  // namespace iree
+
+#endif  // IREE_RT_DISASSEMBLER_H_
diff --git a/iree/rt/instance.h b/iree/rt/instance.h
index f5e3bc8..61fd544 100644
--- a/iree/rt/instance.h
+++ b/iree/rt/instance.h
@@ -21,14 +21,7 @@
 #include "iree/base/ref_ptr.h"
 #include "iree/hal/device_manager.h"
 #include "iree/rt/context.h"
-
-namespace iree {
-namespace rt {
-namespace debug {
-class DebugServer;
-}  // namespace debug
-}  // namespace rt
-}  // namespace iree
+#include "iree/rt/debug/debug_server.h"
 
 namespace iree {
 namespace rt {
@@ -46,7 +39,8 @@
 class Instance final : public RefObject<Instance> {
  public:
   // Creates an instance with an optional attached |debug_server|.
-  explicit Instance(std::unique_ptr<debug::DebugServer> debug_server = nullptr);
+  Instance() : Instance(nullptr) {}
+  explicit Instance(std::unique_ptr<debug::DebugServer> debug_server);
   ~Instance();
   Instance(const Instance&) = delete;
   Instance& operator=(const Instance&) = delete;
diff --git a/iree/rt/invocation.cc b/iree/rt/invocation.cc
index f35671e..0abe667 100644
--- a/iree/rt/invocation.cc
+++ b/iree/rt/invocation.cc
@@ -72,7 +72,7 @@
 
   // TODO(benvanik): fiber scheduling and such.
   auto execute_status = function.module()->Execute(
-      function, std::move(arguments), &results_value);
+      &invocation->stack_, function, std::move(arguments), &results_value);
   if (execute_status.ok()) {
     invocation->CompleteSuccess(std::move(results_value));
   } else {
@@ -82,12 +82,33 @@
   return invocation;
 }
 
+// static
+StatusOr<ref_ptr<Invocation>> Invocation::Create(
+    ref_ptr<Context> context, const Function function, ref_ptr<Policy> policy,
+    absl::Span<const ref_ptr<Invocation>> dependencies,
+    absl::Span<const hal::BufferView> arguments) {
+  absl::InlinedVector<ref_ptr<Invocation>, 4> dependency_list;
+  dependency_list.reserve(dependencies.size());
+  for (auto& dependency : dependencies) {
+    dependency_list.push_back(add_ref(dependency));
+  }
+  absl::InlinedVector<hal::BufferView, 8> argument_list;
+  argument_list.reserve(arguments.size());
+  for (auto& buffer_view : arguments) {
+    argument_list.push_back(buffer_view);
+  }
+  return Invocation::Create(std::move(context), function, std::move(policy),
+                            std::move(dependency_list),
+                            std::move(argument_list));
+}
+
 Invocation::Invocation(ref_ptr<Context> context, const Function function,
                        ref_ptr<Policy> policy)
     : id_(NextUniqueInvocationId()),
       context_(std::move(context)),
       function_(function),
-      policy_(std::move(policy)) {
+      policy_(std::move(policy)),
+      stack_(context_.get()) {
   IREE_TRACE_SCOPE0("Invocation::ctor");
   context_->RegisterInvocation(this);
 }
diff --git a/iree/rt/invocation.h b/iree/rt/invocation.h
index b2e79a5..600fd8a 100644
--- a/iree/rt/invocation.h
+++ b/iree/rt/invocation.h
@@ -27,6 +27,7 @@
 #include "iree/hal/buffer_view.h"
 #include "iree/rt/function.h"
 #include "iree/rt/policy.h"
+#include "iree/rt/stack.h"
 #include "iree/rt/stack_trace.h"
 
 namespace iree {
@@ -63,6 +64,10 @@
       absl::InlinedVector<hal::BufferView, 8> arguments,
       absl::optional<absl::InlinedVector<hal::BufferView, 8>> results =
           absl::nullopt);
+  static StatusOr<ref_ptr<Invocation>> Create(
+      ref_ptr<Context> context, const Function function, ref_ptr<Policy> policy,
+      absl::Span<const ref_ptr<Invocation>> dependencies,
+      absl::Span<const hal::BufferView> arguments);
 
   ~Invocation();
 
@@ -126,6 +131,8 @@
   const Function function_;
   ref_ptr<Policy> policy_;
 
+  Stack stack_;
+
   absl::Mutex status_mutex_;
   Status completion_status_ ABSL_GUARDED_BY(status_mutex_) =
       UnavailableErrorBuilder(IREE_LOC);
diff --git a/iree/rt/module.h b/iree/rt/module.h
index d81572e..1878d9d 100644
--- a/iree/rt/module.h
+++ b/iree/rt/module.h
@@ -27,7 +27,9 @@
 namespace iree {
 namespace rt {
 
+class Disassembler;
 class SourceResolver;
+class Stack;
 
 // Abstract compiled module interface for resolving functions.
 //
@@ -50,6 +52,11 @@
   // May be nullptr if debugging info has been stripped.
   virtual SourceResolver* source_resolver() const = 0;
 
+  // Returns a disassembler that can be used to disassemble functions in the
+  // module. May be nullptr if debugging info has been stripped or disassembly
+  // has been disabled as a compile option.
+  virtual Disassembler* disassembler() const = 0;
+
   // A short human-readable string that matches the compiler formatting.
   virtual std::string DebugStringShort() const = 0;
 
@@ -82,7 +89,7 @@
 
   // Temporary until scheduler is built.
   virtual Status Execute(
-      const Function function,
+      Stack* stack, const Function function,
       absl::InlinedVector<hal::BufferView, 8> arguments,
       absl::InlinedVector<hal::BufferView, 8>* results) const = 0;
 
diff --git a/iree/rt/module_printer.cc b/iree/rt/module_printer.cc
new file mode 100644
index 0000000..dd0267e
--- /dev/null
+++ b/iree/rt/module_printer.cc
@@ -0,0 +1,65 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "iree/rt/module_printer.h"
+
+#include <iomanip>
+
+#include "iree/rt/disassembler.h"
+#include "iree/rt/source_resolver.h"
+
+namespace iree {
+namespace rt {
+
+Status PrintModuleToStream(const Module& module, PrintModuleFlagBitfield flags,
+                           std::ostream* stream) {
+  *stream << "Imports:\n";
+  for (int i = 0; i < module.signature().import_function_count(); ++i) {
+    ASSIGN_OR_RETURN(auto function, module.LookupFunctionByOrdinal(
+                                        Function::Linkage::kImport, i));
+    *stream << "  " << i << ": " << function << "\n";
+  }
+  *stream << "Exports:\n";
+  for (int i = 0; i < module.signature().export_function_count(); ++i) {
+    ASSIGN_OR_RETURN(auto function, module.LookupFunctionByOrdinal(
+                                        Function::Linkage::kExport, i));
+    *stream << "  " << i << ": " << function << "\n";
+  }
+  if (module.signature().internal_function_count()) {
+    *stream << "Internal:\n";
+    auto* disassembler = module.disassembler();
+    for (int i = 0; i < module.signature().internal_function_count(); ++i) {
+      ASSIGN_OR_RETURN(auto function, module.LookupFunctionByOrdinal(
+                                          Function::Linkage::kInternal, i));
+      *stream << "  " << i << ": " << function << "\n";
+      if (disassembler && AllBitsSet(flags, PrintModuleFlag::kDisassemble)) {
+        auto instructions_or =
+            disassembler->DisassembleInstructions(function, 0);
+        if (IsUnavailable(instructions_or.status())) continue;
+        for (const auto& instruction : instructions_or.ValueOrDie()) {
+          *stream << "    " << std::setw(6) << instruction.offset << ": "
+                  << instruction.long_text << "\n";
+        }
+      }
+    }
+  }
+  return OkStatus();
+}
+
+Status PrintModuleToStream(const Module& module, std::ostream* stream) {
+  return PrintModuleToStream(module, PrintModuleFlag::kNone, stream);
+}
+
+}  // namespace rt
+}  // namespace iree
diff --git a/iree/vm/module_printer.h b/iree/rt/module_printer.h
similarity index 67%
rename from iree/vm/module_printer.h
rename to iree/rt/module_printer.h
index ee35fb3..945dbbd 100644
--- a/iree/vm/module_printer.h
+++ b/iree/rt/module_printer.h
@@ -12,33 +12,31 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef IREE_VM_MODULE_PRINTER_H_
-#define IREE_VM_MODULE_PRINTER_H_
+#ifndef IREE_RT_MODULE_PRINTER_H_
+#define IREE_RT_MODULE_PRINTER_H_
 
 #include <ostream>
 
 #include "iree/base/bitfield.h"
 #include "iree/base/status.h"
-#include "iree/vm/module.h"
-#include "iree/vm/opcode_info.h"
+#include "iree/rt/module.h"
 
 namespace iree {
-namespace vm {
+namespace rt {
 
 enum class PrintModuleFlag {
   kNone = 0,
-  kIncludeSourceMapping = 1,
+  kDisassemble = 1 << 0,
 };
 IREE_BITFIELD(PrintModuleFlag);
 using PrintModuleFlagBitfield = PrintModuleFlag;
 
 // Prints all functions within the module to the given |stream|.
-Status PrintModuleToStream(OpcodeTable opcode_table, const Module& module,
+Status PrintModuleToStream(const Module& module, std::ostream* stream);
+Status PrintModuleToStream(const Module& module, PrintModuleFlagBitfield flags,
                            std::ostream* stream);
-Status PrintModuleToStream(OpcodeTable opcode_table, const Module& module,
-                           PrintModuleFlagBitfield flags, std::ostream* stream);
 
-}  // namespace vm
+}  // namespace rt
 }  // namespace iree
 
-#endif  // IREE_VM_MODULE_PRINTER_H_
+#endif  // IREE_RT_MODULE_PRINTER_H_
diff --git a/iree/rt/source_location.cc b/iree/rt/source_location.cc
index c61645f..835905b 100644
--- a/iree/rt/source_location.cc
+++ b/iree/rt/source_location.cc
@@ -14,14 +14,18 @@
 
 #include "iree/rt/source_location.h"
 
+#include <sstream>
+
 #include "iree/rt/source_resolver.h"
 
 namespace iree {
 namespace rt {
 
 std::string SourceLocation::DebugStringShort() const {
-  // TODO(benvanik): ask source resolver.
-  return "<source>";
+  if (is_unknown()) return "(unknown)";
+  std::ostringstream stream;
+  resolver_->PrintSourceLocation(resolver_args_, &stream);
+  return stream.str();
 }
 
 }  // namespace rt
diff --git a/iree/rt/source_location.h b/iree/rt/source_location.h
index 9939e15..7db98ec 100644
--- a/iree/rt/source_location.h
+++ b/iree/rt/source_location.h
@@ -15,6 +15,7 @@
 #ifndef IREE_RT_SOURCE_LOCATION_H_
 #define IREE_RT_SOURCE_LOCATION_H_
 
+#include <array>
 #include <cstdint>
 #include <cstring>
 #include <ostream>
@@ -31,6 +32,10 @@
 // hash table.
 using SourceOffset = int64_t;
 
+// Implementation-defined opaque args stored within source locations that can be
+// used by a SourceResolver to map back to its internal storage.
+using SourceResolverArgs = std::array<uint64_t, 2>;
+
 // A location within a source file.
 // Only valid for the lifetime of the SourceResolver that returned it.
 class SourceLocation final {
@@ -40,15 +45,12 @@
 
   // Returns true if the two source locations reference the same target.
   inline static bool Equal(const SourceLocation& a, const SourceLocation& b) {
-    return a.resolver_ == b.resolver_ &&
-           std::memcmp(a.resolver_args_, b.resolver_args_,
-                       sizeof(a.resolver_args_)) == 0;
+    return a.resolver_ == b.resolver_ && a.resolver_args_ == b.resolver_args_;
   }
 
   SourceLocation() = default;
-  SourceLocation(SourceResolver* resolver, uintptr_t resolver_args[2])
-      : resolver_(resolver),
-        resolver_args_{resolver_args[0], resolver_args[1]} {}
+  SourceLocation(SourceResolver* resolver, SourceResolverArgs resolver_args)
+      : resolver_(resolver), resolver_args_(resolver_args) {}
 
   // A short one-line human readable string (such as file/line number).
   std::string DebugStringShort() const;
@@ -63,7 +65,7 @@
 
  private:
   SourceResolver* resolver_ = nullptr;
-  uintptr_t resolver_args_[2] = {0, 0};
+  SourceResolverArgs resolver_args_ = {0, 0};
 };
 
 inline bool operator==(const SourceLocation& a, const SourceLocation& b) {
diff --git a/iree/rt/source_resolver.h b/iree/rt/source_resolver.h
index fd677a2..3ceb1b9 100644
--- a/iree/rt/source_resolver.h
+++ b/iree/rt/source_resolver.h
@@ -15,14 +15,21 @@
 #ifndef IREE_RT_SOURCE_RESOLVER_H_
 #define IREE_RT_SOURCE_RESOLVER_H_
 
+#include <cstdint>
+#include <ostream>
+#include <vector>
+
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "iree/base/status.h"
 #include "iree/rt/function.h"
 #include "iree/rt/source_location.h"
 
 namespace iree {
 namespace rt {
 
-// Resolves offsets within functions to SourceLocations.
+// Resolves offsets within functions to SourceLocations and provides source
+// language services.
 //
 // Thread-safe.
 class SourceResolver {
@@ -34,6 +41,11 @@
   virtual absl::optional<SourceLocation> ResolveFunctionOffset(
       const Function& function, SourceOffset offset) = 0;
 
+  // Converts a source location to a human-readable string, commonly in a single
+  // line denoting an original source file location (such as path:line:col).
+  virtual void PrintSourceLocation(SourceResolverArgs resolver_args,
+                                   std::ostream* stream) const = 0;
+
   // TODO(benvanik): query local variable names.
 
   // TODO(benvanik): step target calculation (relative mapping).
diff --git a/iree/rt/stack.cc b/iree/rt/stack.cc
new file mode 100644
index 0000000..f4f300f
--- /dev/null
+++ b/iree/rt/stack.cc
@@ -0,0 +1,60 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "iree/rt/stack.h"
+
+#include <iterator>
+
+#include "absl/strings/str_join.h"
+#include "iree/base/status.h"
+
+namespace iree {
+namespace rt {
+
+constexpr int Stack::kMaxStackDepth;
+
+Stack::Stack(Context* context) : context_(context) {}
+
+Stack::~Stack() = default;
+
+StatusOr<StackFrame*> Stack::PushFrame(Function function) {
+  if (stack_depth_ + 1 > kMaxStackDepth) {
+    return InternalErrorBuilder(IREE_LOC)
+           << "Max stack depth of " << kMaxStackDepth << " exceeded";
+  }
+  frames_[stack_depth_++] = StackFrame(function);
+
+  // TODO(benvanik): WTF scope enter.
+
+  return current_frame();
+}
+
+Status Stack::PopFrame() {
+  if (stack_depth_ == 0) {
+    return InternalErrorBuilder(IREE_LOC) << "Unbalanced stack pop";
+  }
+
+  // TODO(benvanik): WTF scope leave.
+
+  --stack_depth_;
+  frames_[stack_depth_] = {};
+  return OkStatus();
+}
+
+std::string Stack::DebugString() const {
+  return absl::StrJoin(frames(), "\n", StackFrameFormatter());
+}
+
+}  // namespace rt
+}  // namespace iree
diff --git a/iree/rt/stack.h b/iree/rt/stack.h
new file mode 100644
index 0000000..a9547fe
--- /dev/null
+++ b/iree/rt/stack.h
@@ -0,0 +1,85 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_RT_STACK_H_
+#define IREE_RT_STACK_H_
+
+#include <functional>
+
+#include "absl/types/span.h"
+#include "iree/base/status.h"
+#include "iree/rt/stack_frame.h"
+
+namespace iree {
+namespace rt {
+
+class Context;
+
+// A runtime call stack for managing stack frames.
+// The frames within a stack may be from different backends and may provide
+// varying levels of information based on capabilities.
+//
+// Thread-compatible. Do not attempt to investigate a stack while another thread
+// may be mutating it!
+class Stack final {
+ public:
+  static constexpr int kMaxStackDepth = 32;
+
+  explicit Stack(Context* context);
+  Stack(const Stack&) = delete;
+  Stack& operator=(const Stack&) = delete;
+  ~Stack();
+
+  // Context defining the module and global workspaces.
+  Context* context() const { return context_; }
+
+  // All stack frames within the stack.
+  absl::Span<StackFrame> frames() {
+    return absl::MakeSpan(frames_).subspan(0, stack_depth_);
+  }
+  absl::Span<const StackFrame> frames() const {
+    return absl::MakeConstSpan(frames_).subspan(0, stack_depth_);
+  }
+
+  // The current stack frame.
+  StackFrame* current_frame() {
+    return stack_depth_ > 0 ? &frames_[stack_depth_ - 1] : nullptr;
+  }
+
+  // The stack frame of the caller of the current function.
+  StackFrame* caller_frame() {
+    return stack_depth_ > 1 ? &frames_[stack_depth_ - 2] : nullptr;
+  }
+
+  StatusOr<StackFrame*> PushFrame(Function function);
+  Status PopFrame();
+
+  // Returns a full stack frame listing in human-readable form.
+  std::string DebugString() const;
+
+ private:
+  Context* context_ = nullptr;
+  std::array<StackFrame, kMaxStackDepth> frames_;
+  int stack_depth_ = 0;
+};
+
+inline std::ostream& operator<<(std::ostream& stream, const Stack& stack) {
+  stream << stack.DebugString();
+  return stream;
+}
+
+}  // namespace rt
+}  // namespace iree
+
+#endif  // IREE_RT_STACK_H_
diff --git a/iree/rt/stack_frame.h b/iree/rt/stack_frame.h
index 573e48e..bb77ef4 100644
--- a/iree/rt/stack_frame.h
+++ b/iree/rt/stack_frame.h
@@ -17,6 +17,7 @@
 
 #include <ostream>
 
+#include "absl/types/span.h"
 #include "iree/rt/function.h"
 #include "iree/rt/module.h"
 #include "iree/rt/source_location.h"
@@ -24,6 +25,12 @@
 namespace iree {
 namespace rt {
 
+// TODO(benvanik): allocate in-place from an arena.
+// Register table used within a stack frame.
+struct Registers {
+  std::vector<hal::BufferView> buffer_views;
+};
+
 // A single frame on the call stack containing current execution state and
 // register values.
 //
@@ -35,12 +42,15 @@
 // but instead just routing to the real storage via indirection. If the debugger
 // is not attached and no errors are hit then no additional bookkeeping is done.
 //
-// Thread-compatible, as is the owning StackTrace.
+// Thread-compatible, as is the owning Stack/StackTrace.
 class StackFrame final {
  public:
   StackFrame() = default;
-  explicit StackFrame(Function function, SourceOffset offset)
-      : function_(function), offset_(offset) {}
+  explicit StackFrame(Function function) : function_(function) {}
+  StackFrame(Function function, SourceOffset offset, Registers registers)
+      : function_(function),
+        offset_(offset),
+        registers_(std::move(registers)) {}
   StackFrame(const StackFrame&) = delete;
   StackFrame& operator=(const StackFrame&) = delete;
   StackFrame(StackFrame&&) = default;
@@ -57,15 +67,17 @@
   // treat them as opaque and must use the SourceResolver to compute new
   // offsets (such as 'next offset').
   SourceOffset offset() const { return offset_; }
+  SourceOffset* mutable_offset() { return &offset_; }
 
   // Returns a source location, if available, for the current offset within the
   // target function.
   absl::optional<SourceLocation> source_location() const;
 
-  // TODO(benvanik): register access:
-  //   query total register layout for stack frame
-  //   get register in stack frame
-  //   set register in stack frame
+  // Registers used within the stack frame.
+  // Storage is implementation-defined and is valid only for the lifetime of the
+  // frame.
+  const Registers& registers() const { return registers_; }
+  Registers* mutable_registers() { return &registers_; }
 
   // A short human-readable string for the frame; a single line.
   std::string DebugStringShort() const;
@@ -73,6 +85,13 @@
  private:
   Function function_;
   SourceOffset offset_ = 0;
+  Registers registers_;
+};
+
+struct StackFrameFormatter {
+  void operator()(std::string* out, const StackFrame& stack_frame) const {
+    out->append(stack_frame.DebugStringShort());
+  }
 };
 
 inline std::ostream& operator<<(std::ostream& stream,
diff --git a/iree/rt/stack_trace.cc b/iree/rt/stack_trace.cc
index a5fdf33..ace8803 100644
--- a/iree/rt/stack_trace.cc
+++ b/iree/rt/stack_trace.cc
@@ -20,14 +20,6 @@
 namespace iree {
 namespace rt {
 
-namespace {
-struct StackFrameFormatter {
-  void operator()(std::string* out, const StackFrame& stack_frame) const {
-    out->append(stack_frame.DebugStringShort());
-  }
-};
-}  // namespace
-
 std::string StackTrace::DebugString() const {
   return absl::StrJoin(frames_, "\n", StackFrameFormatter());
 }
diff --git a/iree/rt/stack_trace.h b/iree/rt/stack_trace.h
index 0c0612b..beca466 100644
--- a/iree/rt/stack_trace.h
+++ b/iree/rt/stack_trace.h
@@ -25,12 +25,13 @@
 namespace iree {
 namespace rt {
 
-// A snapshot of the runtime callstack providing access to stack frames.
+// A snapshot of a stack at a point in time.
 // The frames within a stack may be from different backends and may provide
 // varying levels of information based on capabilities.
 //
-// Thread-compatible. Execution on one thread and stack manipulation on another
-// must be externally synchronized by the caller.
+// Depending on the capture options the trace may contain references to register
+// values (such as buffers) from the time of capture. If the buffers were
+// modified after the capture was taken those results will be reflected!
 class StackTrace final {
  public:
   StackTrace() = default;
@@ -45,16 +46,6 @@
     return absl::MakeConstSpan(frames_);
   }
 
-  // The current stack frame.
-  const StackFrame* current_frame() const {
-    return !frames_.empty() ? &frames_[frames_.size() - 1] : nullptr;
-  }
-
-  // The stack frame of the caller of the current function.
-  const StackFrame* caller_frame() const {
-    return frames_.size() > 1 ? &frames_[frames_.size() - 2] : nullptr;
-  }
-
   // Returns a full stack frame listing in human-readable form.
   std::string DebugString() const;
 
diff --git a/iree/samples/CMakeLists.txt b/iree/samples/CMakeLists.txt
index 48bf62c..ae75ec9 100644
--- a/iree/samples/CMakeLists.txt
+++ b/iree/samples/CMakeLists.txt
@@ -13,4 +13,4 @@
 # limitations under the License.
 
 add_subdirectory(hal)
-add_subdirectory(vm)
+add_subdirectory(rt)
diff --git a/iree/samples/hal/BUILD b/iree/samples/hal/BUILD
index f29844b..8fa22bf 100644
--- a/iree/samples/hal/BUILD
+++ b/iree/samples/hal/BUILD
@@ -2,14 +2,14 @@
 # These do not rely on higher layers of the system (such as the VM or runtime).
 
 load("//iree:build_defs.bzl", "PLATFORM_VULKAN_TEST_DEPS")
-load("//iree/tools:compilation.bzl", "iree_module")
+load("//iree/tools:compilation.bzl", "iree_bytecode_module")
 
 package(
     default_visibility = ["//visibility:public"],
     licenses = ["notice"],  # Apache 2.0
 )
 
-iree_module(
+iree_bytecode_module(
     name = "simple_compute_test_module",
     srcs = ["simple_compute_test.mlir"],
     cc_namespace = "iree::hal::samples",
diff --git a/iree/samples/hal/simple_compute_test.cc b/iree/samples/hal/simple_compute_test.cc
index ac2986b..43f0c48 100644
--- a/iree/samples/hal/simple_compute_test.cc
+++ b/iree/samples/hal/simple_compute_test.cc
@@ -21,8 +21,8 @@
 // imports requiring runtime support, uses floats exclusively (as that's assumed
 // available everywhere), etc.
 //
-// The `iree_module` build rule is used to translate the MLIR to the module
-// flatbuffer. Additional target support can be defined there.
+// The `iree_bytecode_module` build rule is used to translate the MLIR to the
+// module flatbuffer. Additional target support can be defined there.
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
diff --git a/iree/samples/vm/BUILD b/iree/samples/rt/BUILD
similarity index 69%
rename from iree/samples/vm/BUILD
rename to iree/samples/rt/BUILD
index 2a1a94c..2712b07 100644
--- a/iree/samples/vm/BUILD
+++ b/iree/samples/rt/BUILD
@@ -1,21 +1,21 @@
-# Samples demonstrating use of the VM API.
+# Samples demonstrating use of the RT API.
 
-load("//iree/tools:compilation.bzl", "iree_module")
+load("//iree/tools:compilation.bzl", "iree_bytecode_module")
 
 package(
     default_visibility = ["//visibility:public"],
     licenses = ["notice"],  # Apache 2.0
 )
 
-iree_module(
-    name = "simple_module_test_module",
+iree_bytecode_module(
+    name = "simple_module_test_bytecode_module",
     srcs = ["simple_module_test.mlir"],
-    cc_namespace = "iree::vm::samples",
+    cc_namespace = "iree::rt::samples",
 )
 
 cc_test(
-    name = "simple_module_test",
-    srcs = ["simple_module_test.cc"],
+    name = "bytecode_module_test",
+    srcs = ["bytecode_module_test.cc"],
     data = [
         # When building with --config=asan you must specify the following
         # envvar when using Vulkan + a local Nvidia GPU:
@@ -23,20 +23,18 @@
         "//iree/tools:sanitizer_suppressions.txt",
     ],
     deps = [
-        ":simple_module_test_module_cc",
+        ":simple_module_test_bytecode_module_cc",
         "@com_google_googletest//:gtest_main",
         "@com_google_absl//absl/strings",
         "//iree/base:flatbuffer_util",
+        "//iree/base:status",
         "//iree/base:status_matchers",
         "//iree/hal:buffer_view",
-        "//iree/hal:command_buffer",
-        "//iree/hal:command_queue",
         "//iree/hal:driver_registry",
+        "//iree/rt",
         "//iree/schemas",
-        "//iree/base:status",
-        "//iree/vm:fiber_state",
-        "//iree/vm:instance",
-        "//iree/vm:sequencer_context",
+        "//iree/vm:bytecode_module",
+        "//iree/vm:sequencer_module",
 
         # These are the drivers we support running with and can produce
         # executables for from the source MLIR.
diff --git a/iree/samples/vm/CMakeLists.txt b/iree/samples/rt/CMakeLists.txt
similarity index 82%
rename from iree/samples/vm/CMakeLists.txt
rename to iree/samples/rt/CMakeLists.txt
index 1c36407..ec6ee74 100644
--- a/iree/samples/vm/CMakeLists.txt
+++ b/iree/samples/rt/CMakeLists.txt
@@ -14,9 +14,9 @@
 
 iree_cc_test(
   NAME
-    simple_module_test
+    bytecode_module_test
   SRCS
-    "simple_module_test.cc"
+    "bytecode_module_test.cc"
   DEPS
     absl::strings
     gtest_main
@@ -24,13 +24,10 @@
     iree::base::status
     iree::base::status_matchers
     iree::hal::buffer_view
-    iree::hal::command_buffer
-    iree::hal::command_queue
     iree::hal::driver_registry
     iree::schemas
-    iree::vm::fiber_state
-    iree::vm::instance
-    iree::vm::sequencer_context
+    iree::rt
+    iree::vm::bytecode_module
     # Enabled drivers:
     iree::hal::interpreter::interpreter_driver_module
     iree::hal::vulkan::vulkan_driver_module
diff --git a/iree/samples/vm/simple_module_test.cc b/iree/samples/rt/bytecode_module_test.cc
similarity index 79%
rename from iree/samples/vm/simple_module_test.cc
rename to iree/samples/rt/bytecode_module_test.cc
index 8db859e..2fdc7cf 100644
--- a/iree/samples/vm/simple_module_test.cc
+++ b/iree/samples/rt/bytecode_module_test.cc
@@ -25,6 +25,8 @@
 // The `iree_module` build rule is used to translate the MLIR to the module
 // flatbuffer. Additional HAL backend target support can be defined there.
 
+#include "iree/vm/bytecode_module.h"
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/strings/str_replace.h"
@@ -32,23 +34,20 @@
 #include "iree/base/status.h"
 #include "iree/base/status_matchers.h"
 #include "iree/hal/buffer_view.h"
-#include "iree/hal/command_buffer.h"
-#include "iree/hal/command_queue.h"
 #include "iree/hal/driver_registry.h"
-#include "iree/samples/vm/simple_module_test_module.h"
+#include "iree/rt/context.h"
+#include "iree/rt/instance.h"
+#include "iree/samples/rt/simple_module_test_bytecode_module.h"
 #include "iree/schemas/module_def_generated.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/sequencer_context.h"
+#include "iree/vm/sequencer_module.h"
 
 namespace iree {
-namespace vm {
+namespace rt {
 namespace samples {
 namespace {
 
-using iree::hal::BufferView;
-
-using ModuleFile = FlatBufferFile<ModuleDef>;
+using ::iree::hal::BufferView;
+using ::iree::vm::ModuleFile;
 
 struct TestParams {
   // HAL driver to use for the test.
@@ -77,7 +76,7 @@
 };
 
 TEST_P(SimpleModuleTest, RunOnce) {
-  auto instance = std::make_shared<Instance>();
+  auto instance = make_ref<Instance>();
 
   // Create driver for this test (based on params) and then get a default
   // device.
@@ -105,22 +104,20 @@
   // Make a new context and load the precompiled module file (from
   // simple_module_test.mlir) into it.
   LOG(INFO) << "Loading simple_module_test.mlir...";
-  SequencerContext context(instance);
-  const auto* module_file_toc = simple_module_test_module_create();
-  ASSERT_OK_AND_ASSIGN(
-      auto module_file,
-      ModuleFile::WrapBuffer(ModuleDefIdentifier(),
-                             absl::MakeSpan(reinterpret_cast<const uint8_t*>(
-                                                module_file_toc->data),
-                                            module_file_toc->size)));
+  auto policy = make_ref<Policy>();
+  Context context(add_ref(instance), add_ref(policy));
+  const auto* module_file_toc = simple_module_test_bytecode_module_create();
+  ASSERT_OK_AND_ASSIGN(auto module_file,
+                       vm::ModuleFile::WrapBuffer(
+                           ModuleDefIdentifier(),
+                           absl::MakeSpan(reinterpret_cast<const uint8_t*>(
+                                              module_file_toc->data),
+                                          module_file_toc->size)));
   ASSERT_OK_AND_ASSIGN(auto main_module,
-                       Module::FromFile(std::move(module_file)));
+                       vm::SequencerModule::FromFile(std::move(module_file)));
   ASSERT_OK(context.RegisterModule(std::move(main_module)));
   LOG(INFO) << "Module loaded and context is ready for use";
 
-  // In this sample we just have a single fiber.
-  FiberState fiber_state(instance);
-
   // Allocate buffers that can be mapped on the CPU and that can also be used
   // on the device. Not all devices support this, but the ones we have now do.
   LOG(INFO) << "Creating I/O buffers...";
@@ -140,14 +137,17 @@
 
   // Call into the @simple_mul function.
   LOG(INFO) << "Calling @simple_mul...";
-  std::vector<BufferView> args{
+  absl::InlinedVector<BufferView, 8> args{
       BufferView{add_ref(arg0_buffer), {kElementCount}, sizeof(float)},
       BufferView{add_ref(arg1_buffer), {kElementCount}, sizeof(float)},
   };
-  std::vector<BufferView> results{1};
-  ASSERT_OK_AND_ASSIGN(auto simple_mul, context.LookupExport("simple_mul"));
-  ASSERT_OK(context.Invoke(&fiber_state, simple_mul, absl::MakeSpan(args),
-                           absl::MakeSpan(results)));
+  ASSERT_OK_AND_ASSIGN(auto simple_mul,
+                       context.ResolveFunction("module.simple_mul"));
+  ASSERT_OK_AND_ASSIGN(auto invocation,
+                       Invocation::Create(add_ref(&context), simple_mul,
+                                          nullptr, {}, std::move(args)));
+  ASSERT_OK(invocation->Await(absl::InfiniteFuture()));
+  ASSERT_OK_AND_ASSIGN(auto results, invocation->ConsumeResults());
 
   // Read back the results and ensure we got the right values.
   LOG(INFO) << "Reading back results...";
@@ -166,5 +166,5 @@
 
 }  // namespace
 }  // namespace samples
-}  // namespace vm
+}  // namespace rt
 }  // namespace iree
diff --git a/iree/samples/vm/simple_module_test.mlir b/iree/samples/rt/simple_module_test.mlir
similarity index 100%
rename from iree/samples/vm/simple_module_test.mlir
rename to iree/samples/rt/simple_module_test.mlir
diff --git a/iree/tools/BUILD b/iree/tools/BUILD
index 6d15ade..3fa849c 100644
--- a/iree/tools/BUILD
+++ b/iree/tools/BUILD
@@ -37,6 +37,8 @@
         "@com_google_absl//absl/flags:flag",
         "@com_google_absl//absl/strings",
         "//iree/base:source_location",
+        "//iree/rt",
+        "//iree/vm:sequencer_module",
         "@llvm//:support",
         "@local_config_mlir//:IR",
         "@local_config_mlir//:Parser",
@@ -48,19 +50,14 @@
         "//iree/compiler/Translation/SPIRV",
         "//iree/hal:buffer_view_string_util",
         "//iree/hal:driver_registry",
+        "//iree/schemas",
+        "//iree/rt/debug:debug_server_flags",
+    ] + PLATFORM_VULKAN_DEPS + [
         "//iree/hal/interpreter:interpreter_driver_module",
-        "//iree/hal/vulkan:vulkan_driver_module",
         # TODO(b/142004903): enable when Dawn HAL implementation is functional
         # "//iree/hal/dawn:dawn_driver_module",
-        "//iree/schemas",
-        "//iree/vm:bytecode_tables_sequencer",
-        "//iree/vm:fiber_state",
-        "//iree/vm:instance",
-        "//iree/vm:module",
-        "//iree/vm:module_printer",
-        "//iree/vm:sequencer_context",
-        "//iree/rt/debug:debug_server_flags",
-    ] + PLATFORM_VULKAN_DEPS,
+        "//iree/hal/vulkan:vulkan_driver_module",
+    ],
 )
 
 cc_binary(
@@ -94,16 +91,10 @@
         "//iree/hal:buffer_view_string_util",
         "//iree/hal:driver_registry",
         "//iree/hal/interpreter:interpreter_driver_module",
+        "//iree/rt",
         "//iree/rt/debug:debug_server_flags",
         "//iree/schemas",
-        "//iree/vm:bytecode_printer",
-        "//iree/vm:bytecode_tables_sequencer",
-        "//iree/vm:fiber_state",
-        "//iree/vm:function",
-        "//iree/vm:instance",
-        "//iree/vm:module",
-        "//iree/vm:module_printer",
-        "//iree/vm:sequencer_context",
+        "//iree/vm:sequencer_module",
         "@com_google_absl//absl/flags:flag",
         "@com_google_absl//absl/strings",
     ],
diff --git a/iree/tools/compilation.bzl b/iree/tools/compilation.bzl
index 5d1ffe5..b232099 100644
--- a/iree/tools/compilation.bzl
+++ b/iree/tools/compilation.bzl
@@ -3,7 +3,7 @@
 load("//build_tools/embed_data:build_defs.bzl", "cc_embed_data")
 
 # TODO(benvanik): port to a full starlark rule, document, etc.
-def iree_module(
+def iree_bytecode_module(
         name,
         srcs,
         cc_namespace = None,
diff --git a/iree/tools/debugger/BUILD b/iree/tools/debugger/BUILD
index b1f432b..e3b90a4 100644
--- a/iree/tools/debugger/BUILD
+++ b/iree/tools/debugger/BUILD
@@ -7,7 +7,8 @@
 # By default the IREE runtime does not compile in debug support. To link it in
 # pass --define=IREE_DEBUG=1 to bazel builds of the runtime.
 
-load("//third_party/emscripten:split_transition_defs.bzl", "auto_wasm_binary")
+# TODO(benvanik): re-enable debugger after refactoring.
+# load("//third_party/emscripten:split_transition_defs.bzl", "auto_wasm_binary")
 
 package(
     default_visibility = ["//visibility:public"],
@@ -41,10 +42,6 @@
 #         "//iree/base:status",
 #         "//iree/rt/debug:debug_client",
 #         "//iree/schemas",
-#         "//iree/vm:bytecode_printer",
-#         "//iree/vm:bytecode_tables_sequencer",
-#         "//iree/vm:module",
-#         "//iree/vm:source_map",
 #     ],
 # )
 #
diff --git a/iree/tools/debugger/debug_app.cc b/iree/tools/debugger/debug_app.cc
index 793f4a1..303979e 100644
--- a/iree/tools/debugger/debug_app.cc
+++ b/iree/tools/debugger/debug_app.cc
@@ -31,10 +31,8 @@
 #include "iree/base/status.h"
 #include "iree/rt/debug/debug_client.h"
 #include "iree/schemas/debug_service_generated.h"
-#include "iree/vm/bytecode_printer.h"
+#include "iree/vm/bytecode_module.h"
 #include "iree/vm/bytecode_tables_sequencer.h"
-#include "iree/vm/module.h"
-#include "iree/vm/source_map.h"
 
 namespace iree {
 namespace rt {
@@ -1311,21 +1309,7 @@
   auto* remote_module = document->function->module();
   auto* remote_function = document->function;
 
-  ASSIGN_OR_RETURN(auto module, vm::Module::FromDef(remote_module->def()));
-
-  // TODO(benvanik): source map support.
-  // Want line count including source lines, IR lines, and bytecode lines.
-  // May want lower level (JIT/etc) lines too.
-
-  // TODO(benvanik): bytecode iterator for richer display.
-  auto source_map_resolver = vm::SourceMapResolver::FromFunction(
-      module->def(), remote_function->ordinal());
-  vm::BytecodePrinter printer(vm::sequencer_opcode_table(),
-                              module->function_table(),
-                              module->executable_table(), source_map_resolver);
-  ASSIGN_OR_RETURN(std::string full_string,
-                   printer.Print(*remote_function->bytecode()));
-  document->bytecode_info.lines = absl::StrSplit(full_string, '\n');
+  document->bytecode_info.lines = remote_function->name();
 
   return OkStatus();
 }
diff --git a/iree/tools/run_mlir_main.cc b/iree/tools/run_mlir_main.cc
index 360745e..dfa3486 100644
--- a/iree/tools/run_mlir_main.cc
+++ b/iree/tools/run_mlir_main.cc
@@ -47,14 +47,14 @@
 #include "iree/compiler/Translation/Sequencer/SequencerModuleTranslation.h"
 #include "iree/hal/buffer_view_string_util.h"
 #include "iree/hal/driver_registry.h"
+#include "iree/rt/context.h"
 #include "iree/rt/debug/debug_server_flags.h"
+#include "iree/rt/instance.h"
+#include "iree/rt/invocation.h"
+#include "iree/rt/module.h"
+#include "iree/rt/module_printer.h"
 #include "iree/schemas/module_def_generated.h"
-#include "iree/vm/bytecode_tables_sequencer.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/module.h"
-#include "iree/vm/module_printer.h"
-#include "iree/vm/sequencer_context.h"
+#include "iree/vm/sequencer_module.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SourceMgr.h"
 #include "mlir/IR/Attributes.h"
@@ -92,9 +92,8 @@
 namespace {
 
 using ::iree::hal::BufferView;
-using ::iree::vm::Function;
-using ::iree::vm::Module;
-using ::iree::vm::ModuleFile;
+using ::iree::rt::Function;
+using ::iree::rt::Module;
 
 // Returns a driver name capable of handling input from the given backend.
 std::string BackendToDriverName(std::string backend) {
@@ -107,7 +106,7 @@
 }
 
 // Prepares a module for evaluation by running MLIR import and IREE translation.
-StatusOr<std::unique_ptr<Module>> PrepareModule(
+StatusOr<ref_ptr<Module>> PrepareModule(
     std::string target_backend,
     std::unique_ptr<llvm::MemoryBuffer> file_buffer) {
   mlir::MLIRContext context;
@@ -142,9 +141,9 @@
 
   // Wrap module in a file handle.
   ASSIGN_OR_RETURN(auto iree_module_file,
-                   ModuleFile::FromBuffer(ModuleDefIdentifier(),
-                                          std::move(iree_module_bytes)));
-  return Module::FromFile(std::move(iree_module_file));
+                   vm::ModuleFile::FromBuffer(ModuleDefIdentifier(),
+                                              std::move(iree_module_bytes)));
+  return vm::SequencerModule::FromFile(std::move(iree_module_file));
 }
 
 // Parses a list of input shapes and values from a string of newline-separated
@@ -196,25 +195,22 @@
 }
 
 // Evaluates a single function in its own fiber, printing the results to stdout.
-Status EvaluateFunction(std::shared_ptr<vm::Instance> instance,
-                        vm::SequencerContext* context,
+Status EvaluateFunction(const ref_ptr<rt::Context>& context,
                         hal::Allocator* allocator, const Function& function) {
-  // Setup our dummy fiber we will run with.
-  vm::FiberState fiber_state(instance);
-
   std::cout << "EXEC @" << function.name() << std::endl;
 
-  // Marshal inputs.
-  ASSIGN_OR_RETURN(std::vector<BufferView> args,
-                   ParseInputsFromFlags(allocator));
-  std::vector<BufferView> results;
-  results.resize(function.result_count());
+  // Create invocation that will perform the execution.
+  ASSIGN_OR_RETURN(auto arguments, ParseInputsFromFlags(allocator));
+  ASSIGN_OR_RETURN(
+      auto invocation,
+      rt::Invocation::Create(add_ref(context), function, make_ref<rt::Policy>(),
+                             {}, absl::MakeConstSpan(arguments)));
 
-  // Call into the main function.
-  RETURN_IF_ERROR(context->Invoke(&fiber_state, function, absl::MakeSpan(args),
-                                  absl::MakeSpan(results)));
+  // Wait until invocation completes.
+  RETURN_IF_ERROR(invocation->Await(absl::InfiniteFuture()));
 
   // Print outputs.
+  ASSIGN_OR_RETURN(auto results, invocation->ConsumeResults());
   RETURN_IF_ERROR(OutputFunctionResults(function, absl::MakeSpan(results)));
 
   return OkStatus();
@@ -222,35 +218,33 @@
 
 // Evaluates all exported functions within given module.
 Status EvaluateFunctions(absl::string_view target_backend,
-                         std::unique_ptr<Module> module) {
+                         ref_ptr<Module> module) {
   // Create the context we'll use for this (ensuring that we can't interfere
   // with other running evaluations, such as when in a multithreaded test
   // runner).
   ASSIGN_OR_RETURN(auto debug_server, rt::debug::CreateDebugServerFromFlags());
-  auto instance = std::make_shared<vm::Instance>();
+  auto instance = make_ref<rt::Instance>(std::move(debug_server));
   ASSIGN_OR_RETURN(auto driver, hal::DriverRegistry::shared_registry()->Create(
                                     target_backend));
   ASSIGN_OR_RETURN(auto device, driver->CreateDefaultDevice());
   RETURN_IF_ERROR(instance->device_manager()->RegisterDevice(device));
-  vm::SequencerContext context(instance);
 
   if (absl::GetFlag(FLAGS_print_bytecode)) {
-    vm::PrintModuleFlagBitfield print_flags = vm::PrintModuleFlag::kNone;
-    RETURN_IF_ERROR(vm::PrintModuleToStream(vm::sequencer_opcode_table(),
-                                            *module, print_flags, &std::cout));
+    RETURN_IF_ERROR(rt::PrintModuleToStream(
+        *module, rt::PrintModuleFlag::kDisassemble, &std::cout));
   }
 
-  // Register module with the context.
-  RETURN_IF_ERROR(context.RegisterModule(std::move(module)));
-
   // Evaluate all exported functions.
-  for (auto& module : context.modules()) {
-    for (int function_ordinal : *module->def().function_table()->exports()) {
-      ASSIGN_OR_RETURN(auto function, module->function_table().LookupFunction(
-                                          function_ordinal));
-      RETURN_IF_ERROR(
-          EvaluateFunction(instance, &context, device->allocator(), function));
-    }
+  auto policy = make_ref<rt::Policy>();
+  for (int i = 0; i < module->signature().export_function_count(); ++i) {
+    // Setup a new context for this invocation.
+    auto context = make_ref<rt::Context>(add_ref(instance), add_ref(policy));
+    RETURN_IF_ERROR(context->RegisterModule(add_ref(module)));
+
+    // Invoke the function and print results.
+    ASSIGN_OR_RETURN(auto function, module->LookupFunctionByOrdinal(
+                                        rt::Function::Linkage::kExport, i));
+    RETURN_IF_ERROR(EvaluateFunction(context, device->allocator(), function));
   }
 
   RETURN_IF_ERROR(instance->device_manager()->UnregisterDevice(device.get()));
diff --git a/iree/tools/run_module_main.cc b/iree/tools/run_module_main.cc
index 5fefbfc..be634ee 100644
--- a/iree/tools/run_module_main.cc
+++ b/iree/tools/run_module_main.cc
@@ -27,23 +27,19 @@
 #include "iree/base/status.h"
 #include "iree/hal/buffer_view_string_util.h"
 #include "iree/hal/driver_registry.h"
+#include "iree/rt/context.h"
 #include "iree/rt/debug/debug_server_flags.h"
+#include "iree/rt/instance.h"
+#include "iree/rt/module_printer.h"
 #include "iree/schemas/module_def_generated.h"
-#include "iree/vm/bytecode_printer.h"
-#include "iree/vm/bytecode_tables_sequencer.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/function.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/module.h"
-#include "iree/vm/module_printer.h"
-#include "iree/vm/sequencer_context.h"
+#include "iree/vm/sequencer_module.h"
 
 ABSL_FLAG(std::string, main_module, "", "Main module with entry point.");
 ABSL_FLAG(std::string, main_function, "",
           "Function within the main module to execute.");
 
-ABSL_FLAG(bool, print_source_info, false,
-          "Prints source map information in bytecode output.");
+ABSL_FLAG(bool, print_disassembly, true,
+          "Prints bytecode disassembly for the module.");
 
 ABSL_FLAG(std::string, input_values, "", "Input shapes and optional values.");
 ABSL_FLAG(std::string, input_file, "",
@@ -54,18 +50,15 @@
           "binary/signed int/unsigned int/float).");
 
 namespace iree {
-namespace vm {
 namespace {
 
-using ::iree::hal::BufferView;
-
 // Parses a list of input shapes and values from a string of newline-separated
 // inputs. Expects the contents to have one value per line with each value
 // listed as
 //   [shape]xtype=[value]
 // Example:
 //   4x4xi8=0,1,2,3
-StatusOr<std::vector<BufferView>> ParseInputsFromFlags(
+StatusOr<std::vector<hal::BufferView>> ParseInputsFromFlags(
     hal::Allocator* allocator) {
   std::string file_contents;
   if (!absl::GetFlag(FLAGS_input_values).empty()) {
@@ -75,7 +68,7 @@
     ASSIGN_OR_RETURN(file_contents,
                      file_io::GetFileContents(absl::GetFlag(FLAGS_input_file)));
   }
-  std::vector<BufferView> inputs;
+  std::vector<hal::BufferView> inputs;
   for (const auto& line :
        absl::StrSplit(file_contents, '\n', absl::SkipWhitespace())) {
     ASSIGN_OR_RETURN(auto input,
@@ -89,81 +82,67 @@
 
 Status Run() {
   ASSIGN_OR_RETURN(auto debug_server, rt::debug::CreateDebugServerFromFlags());
-  auto instance = std::make_shared<Instance>();
+  auto instance = make_ref<rt::Instance>(std::move(debug_server));
   ASSIGN_OR_RETURN(auto driver, hal::DriverRegistry::shared_registry()->Create(
                                     "interpreter"));
   ASSIGN_OR_RETURN(auto device, driver->CreateDefaultDevice());
   RETURN_IF_ERROR(instance->device_manager()->RegisterDevice(device));
-  SequencerContext context(instance);
+  auto policy = make_ref<rt::Policy>();
+  auto context = make_ref<rt::Context>(add_ref(instance), std::move(policy));
 
   // Load main module.
   ASSIGN_OR_RETURN(
       auto main_module_file,
-      ModuleFile::LoadFile(ModuleDefIdentifier(),
-                           absl::GetFlag(FLAGS_main_module)),
+      vm::ModuleFile::LoadFile(ModuleDefIdentifier(),
+                               absl::GetFlag(FLAGS_main_module)),
       _ << "while loading module file " << absl::GetFlag(FLAGS_main_module));
   ASSIGN_OR_RETURN(auto main_module,
-                   Module::FromFile(std::move(main_module_file)));
-
-  // Add native functions for use by the module.
-  RETURN_IF_ERROR(context.RegisterNativeFunction(
-      "fabsf",
-      [](Stack* stack, absl::Span<const BufferView> args,
-         absl::Span<BufferView> results) -> Status {
-        // TODO(benvanik): example native functions.
-        LOG(INFO) << "fabsf";
-        return OkStatus();
-      }));
+                   vm::SequencerModule::FromFile(std::move(main_module_file)));
 
   // Register the main module with the context.
   // We could add additional modules (specializations, shared libraries, etc).
   // ModuleFioles are stateless so we could have the same module_file used by
   // multiple contexts simultaneously.
-  auto* main_module_ptr = main_module.get();
-  RETURN_IF_ERROR(context.RegisterModule(std::move(main_module)));
+  RETURN_IF_ERROR(context->RegisterModule(add_ref(main_module)));
 
   // Dump the registered modules.
-  PrintModuleFlagBitfield print_flags = PrintModuleFlag::kNone;
-  if (absl::GetFlag(FLAGS_print_source_info)) {
-    print_flags |= PrintModuleFlag::kIncludeSourceMapping;
+  rt::PrintModuleFlagBitfield print_flags = rt::PrintModuleFlag::kNone;
+  if (absl::GetFlag(FLAGS_print_disassembly)) {
+    print_flags |= rt::PrintModuleFlag::kDisassemble;
   }
-  for (const auto& module : context.modules()) {
-    RETURN_IF_ERROR(PrintModuleToStream(sequencer_opcode_table(), *module,
-                                        print_flags, &std::cout));
+  for (const auto& module : context->modules()) {
+    RETURN_IF_ERROR(PrintModuleToStream(*module, print_flags, &std::cout));
   }
 
-  // Setup a new fiber.
-  FiberState fiber_state(instance);
-
-  // Setup arguments and storage for results.
-  Function main_function;
+  rt::Function main_function;
   if (!absl::GetFlag(FLAGS_main_function).empty()) {
     // User-specified main function.
-    ASSIGN_OR_RETURN(main_function,
-                     context.LookupExport(absl::GetFlag(FLAGS_main_function)));
+    ASSIGN_OR_RETURN(main_function, main_module->LookupFunctionByName(
+                                        rt::Function::Linkage::kExport,
+                                        absl::GetFlag(FLAGS_main_function)));
   } else {
     // No main function specified; to prevent non-deterministic behavior we
     // require one unless there's exactly one exported function in the module.
-    auto* exports = main_module_ptr->function_table().def().exports();
-    if (exports && exports->size() == 1) {
-      ASSIGN_OR_RETURN(
-          main_function,
-          main_module_ptr->function_table().LookupFunction(exports->Get(0)));
+    if (main_module->signature().export_function_count() == 1) {
+      ASSIGN_OR_RETURN(main_function, main_module->LookupFunctionByOrdinal(
+                                          rt::Function::Linkage::kExport, 0));
     } else {
       return InvalidArgumentErrorBuilder(IREE_LOC)
              << "--main_function= must be specified to disambiguate the "
                 "function to run";
     }
   }
-  ASSIGN_OR_RETURN(std::vector<BufferView> args,
-                   ParseInputsFromFlags(device->allocator()));
-  std::vector<BufferView> results;
-  results.resize(main_function.result_count());
 
   // Call into the main function.
-  RETURN_IF_ERROR(context.Invoke(&fiber_state, main_function,
-                                 absl::MakeSpan(args),
-                                 absl::MakeSpan(results)));
+  ASSIGN_OR_RETURN(auto arguments, ParseInputsFromFlags(device->allocator()));
+  ASSIGN_OR_RETURN(auto invocation,
+                   rt::Invocation::Create(add_ref(context), main_function,
+                                          make_ref<rt::Policy>(), {},
+                                          absl::MakeConstSpan(arguments)));
+
+  // Wait until invocation completes.
+  RETURN_IF_ERROR(invocation->Await(absl::InfiniteFuture()));
+  ASSIGN_OR_RETURN(auto results, invocation->ConsumeResults());
 
   // Dump all results to stdout.
   std::vector<std::string> output_types =
@@ -201,5 +180,4 @@
   return 0;
 }
 
-}  // namespace vm
 }  // namespace iree
diff --git a/iree/tools/web/BUILD b/iree/tools/web/BUILD
index 3737e05..f55ef9d 100644
--- a/iree/tools/web/BUILD
+++ b/iree/tools/web/BUILD
@@ -1,12 +1,12 @@
 # IREE web tools.
 
+load("//third_party/emscripten:split_transition_defs.bzl", "auto_wasm_binary")
+
 package(
     default_visibility = ["//visibility:public"],
     licenses = ["notice"],  # Apache 2.0
 )
 
-load("//third_party/emscripten:split_transition_defs.bzl", "auto_wasm_binary")
-
 EMSCRIPTEN_LINKOPTS_COMMON = [
     # Error at compile time on unresolved symbols.
     "-s ERROR_ON_UNDEFINED_SYMBOLS=1",
@@ -58,9 +58,8 @@
         "//iree/hal:buffer_view_string_util",
         "//iree/hal:driver_registry",
         "//iree/hal/interpreter:interpreter_driver_module",
-        "//iree/vm:bytecode_tables_sequencer",
-        "//iree/vm:instance",
-        "//iree/vm:sequencer_context",
+        "//iree/rt",
+        "//iree/vm:sequencer_module",
         "//third_party/emscripten:embind",
     ],
 )
diff --git a/iree/tools/web/run_module_emscripten.cc b/iree/tools/web/run_module_emscripten.cc
index f713807..49d88a7 100644
--- a/iree/tools/web/run_module_emscripten.cc
+++ b/iree/tools/web/run_module_emscripten.cc
@@ -26,14 +26,10 @@
 #include "iree/hal/buffer_view.h"
 #include "iree/hal/buffer_view_string_util.h"
 #include "iree/hal/driver_registry.h"
+#include "iree/rt/context.h"
+#include "iree/rt/instance.h"
 #include "iree/schemas/module_def_generated.h"
-#include "iree/vm/bytecode_tables_sequencer.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/function.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/module.h"
-#include "iree/vm/module_printer.h"
-#include "iree/vm/sequencer_context.h"
+#include "iree/vm/sequencer_module.h"
 
 namespace iree {
 
@@ -59,52 +55,49 @@
 // Runs an IREE module with the provided inputs and returns its outputs.
 StatusOr<std::string> RunIreeModule(std::string module_file_data,
                                     absl::string_view inputs_string) {
-  auto instance = std::make_shared<vm::Instance>();
+  auto instance = make_ref<rt::Instance>();
 
   // Create driver and device.
   ASSIGN_OR_RETURN(auto driver, hal::DriverRegistry::shared_registry()->Create(
                                     "interpreter"));
   ASSIGN_OR_RETURN(auto device, driver->CreateDefaultDevice());
   RETURN_IF_ERROR(instance->device_manager()->RegisterDevice(device));
-  vm::SequencerContext context(instance);
+
+  auto policy = make_ref<rt::Policy>();
+  auto context = make_ref<rt::Context>(add_ref(instance), std::move(policy));
 
   // Load main module FlatBuffer.
   ASSIGN_OR_RETURN(auto main_module_file,
                    FlatBufferFile<ModuleDef>::FromString(ModuleDefIdentifier(),
                                                          module_file_data));
   ASSIGN_OR_RETURN(auto main_module,
-                   vm::Module::FromFile(std::move(main_module_file)));
+                   vm::SequencerModule::FromFile(std::move(main_module_file)));
 
   // Register the main module with the context.
-  RETURN_IF_ERROR(context.RegisterModule(std::move(main_module)));
-
-  // Dump the registered modules.
-  vm::PrintModuleFlagBitfield print_flags =
-      vm::PrintModuleFlag::kIncludeSourceMapping;
-  for (const auto& module : context.modules()) {
-    RETURN_IF_ERROR(vm::PrintModuleToStream(vm::sequencer_opcode_table(),
-                                            *module, print_flags, &std::cout));
-  }
-
-  // Setup a new fiber.
-  vm::FiberState fiber_state(instance);
+  RETURN_IF_ERROR(context->RegisterModule(add_ref(main_module)));
 
   // Setup arguments and storage for results.
-  // TODO(scotttodd): Receive main function name from JS
-  ASSIGN_OR_RETURN(vm::Function main_function, context.LookupExport("main"));
+  // TODO(scotttodd): Receive main function name from JS.
+  ASSIGN_OR_RETURN(auto main_function,
+                   main_module->LookupFunctionByName(
+                       rt::Function::Linkage::kExport, "main"));
 
-  ASSIGN_OR_RETURN(std::vector<hal::BufferView> args,
+  ASSIGN_OR_RETURN(auto arguments,
                    ParseInputs(inputs_string, device->allocator()));
-  std::vector<hal::BufferView> results;
-  results.resize(main_function.result_count());
 
   // Call into the main function.
-  RETURN_IF_ERROR(context.Invoke(&fiber_state, main_function,
-                                 absl::MakeSpan(args),
-                                 absl::MakeSpan(results)));
+  ASSIGN_OR_RETURN(auto invocation,
+                   rt::Invocation::Create(add_ref(context), main_function,
+                                          make_ref<rt::Policy>(), {},
+                                          absl::MakeConstSpan(arguments)));
+
+  // Wait until invocation completes.
+  // TODO(scotttodd): make this an async callback.
+  RETURN_IF_ERROR(invocation->Await(absl::InfiniteFuture()));
+  ASSIGN_OR_RETURN(auto results, invocation->ConsumeResults());
 
   // Dump all results to stdout.
-  // TODO(scotttodd): Receive output types / print mode from JS
+  // TODO(scotttodd): Receive output types / print mode from JS.
   // TODO(scotttodd): Return list of outputs instead of just the first (proto?)
   for (int i = 0; i < results.size(); ++i) {
     const auto& result = results[i];
diff --git a/iree/vm/BUILD b/iree/vm/BUILD
index d65e151..9da6c77 100644
--- a/iree/vm/BUILD
+++ b/iree/vm/BUILD
@@ -6,22 +6,30 @@
 )
 
 cc_library(
-    name = "bytecode_printer",
-    srcs = ["bytecode_printer.cc"],
-    hdrs = ["bytecode_printer.h"],
+    name = "bytecode_module",
+    srcs = [
+        "bytecode_disassembler.cc",
+        "bytecode_module.cc",
+    ],
+    hdrs = [
+        "bytecode_disassembler.h",
+        "bytecode_module.h",
+    ],
     deps = [
         ":bytecode_util",
-        ":executable_table",
-        ":function_table",
-        ":module",
         ":opcode_info",
-        ":source_map",
+        ":source_map_resolver",
         ":type",
+        "//iree/base:flatbuffer_util",
         "//iree/base:status",
+        "//iree/base:tracing",
+        "//iree/hal:buffer_view",
+        "//iree/rt",
         "//iree/schemas",
         "//iree/schemas/bytecode:bytecode_v0",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:inlined_vector",
+        "@com_google_absl//absl/memory",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",
     ],
@@ -32,13 +40,13 @@
     srcs = ["bytecode_reader.cc"],
     hdrs = ["bytecode_reader.h"],
     deps = [
-        ":function",
-        ":stack",
+        ":bytecode_module",
         ":type",
         "//iree/base:shape",
         "//iree/base:status",
         "//iree/hal:buffer_view",
         "//iree/hal:heap_buffer",
+        "//iree/rt",
         "//iree/schemas/bytecode:bytecode_v0",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:inlined_vector",
@@ -80,122 +88,13 @@
     srcs = ["bytecode_validator.cc"],
     hdrs = ["bytecode_validator.h"],
     deps = [
-        ":context",
-        ":module",
+        ":bytecode_module",
         "//iree/base:status",
         "//iree/schemas",
     ],
 )
 
 cc_library(
-    name = "context",
-    srcs = ["context.cc"],
-    hdrs = ["context.h"],
-    deps = [
-        ":function",
-        ":module",
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
-    name = "executable_table",
-    srcs = ["executable_table.cc"],
-    hdrs = ["executable_table.h"],
-    deps = [
-        "//iree/base:flatbuffer_util",
-        "//iree/base:source_location",
-        "//iree/base:status",
-        "//iree/schemas",
-    ],
-)
-
-cc_library(
-    name = "fiber_state",
-    srcs = ["fiber_state.cc"],
-    hdrs = ["fiber_state.h"],
-    deps = [
-        ":instance",
-        ":stack",
-        "//iree/base:status",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
-    name = "function",
-    srcs = ["function.cc"],
-    hdrs = ["function.h"],
-    deps = [
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "//iree/hal:buffer_view",
-        "//iree/schemas",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
-    name = "function_table",
-    srcs = ["function_table.cc"],
-    hdrs = ["function_table.h"],
-    deps = [
-        ":function",
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "//iree/schemas",
-        "@com_google_absl//absl/container:flat_hash_map",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
-    name = "instance",
-    srcs = ["instance.cc"],
-    hdrs = ["instance.h"],
-    deps = [
-        "//iree/base:source_location",
-        "//iree/base:status",
-        "//iree/hal:device_manager",
-        "@com_google_absl//absl/memory",
-    ],
-)
-
-cc_library(
-    name = "module",
-    srcs = ["module.cc"],
-    hdrs = ["module.h"],
-    deps = [
-        ":executable_table",
-        ":function_table",
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "//iree/schemas",
-        "@com_google_absl//absl/memory",
-    ],
-)
-
-cc_library(
-    name = "module_printer",
-    srcs = ["module_printer.cc"],
-    hdrs = ["module_printer.h"],
-    deps = [
-        ":bytecode_printer",
-        ":module",
-        ":opcode_info",
-        ":source_map",
-        "//iree/base:bitfield",
-        "//iree/base:status",
-    ],
-)
-
-cc_library(
     name = "opcode_info",
     hdrs = ["opcode_info.h"],
     deps = [
@@ -207,35 +106,15 @@
 )
 
 cc_library(
-    name = "sequencer_context",
-    srcs = ["sequencer_context.cc"],
-    hdrs = ["sequencer_context.h"],
-    deps = [
-        ":context",
-        ":fiber_state",
-        ":function",
-        ":instance",
-        ":module",
-        ":sequencer_dispatch",
-        "//iree/base:flatbuffer_util",
-        "//iree/base:status",
-        "//iree/hal:buffer_view",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
-    ],
-)
-
-cc_library(
     name = "sequencer_dispatch",
     srcs = ["sequencer_dispatch.cc"],
     hdrs = ["sequencer_dispatch.h"],
     deps = [
+        ":bytecode_module",
         ":bytecode_reader",
         ":bytecode_tables_sequencer",
         ":bytecode_util",
-        ":function",
         ":opcode_info",
-        ":stack",
         "//iree/base:logging",
         "//iree/base:memory",
         "//iree/base:status",
@@ -244,6 +123,7 @@
         "//iree/hal:device",
         "//iree/hal:device_placement",
         "//iree/hal:heap_buffer",
+        "//iree/rt",
         "//iree/schemas/bytecode:sequencer_bytecode_v0",
         "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/container:inlined_vector",
@@ -254,35 +134,32 @@
 )
 
 cc_library(
-    name = "source_map",
-    srcs = ["source_map.cc"],
-    hdrs = ["source_map.h"],
+    name = "sequencer_module",
+    srcs = ["sequencer_module.cc"],
+    hdrs = ["sequencer_module.h"],
     deps = [
-        "//iree/base:flatbuffer_util",
+        ":bytecode_module",
+        ":bytecode_tables_sequencer",
+        ":sequencer_dispatch",
         "//iree/base:status",
-        "//iree/schemas",
-        "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:optional",
+        "//iree/base:tracing",
+        "//iree/hal:buffer_view",
+        "//iree/rt",
+        "@com_google_absl//absl/memory",
     ],
 )
 
 cc_library(
-    name = "stack",
-    srcs = [
-        "stack.cc",
-        "stack_frame.cc",
-    ],
-    hdrs = [
-        "stack.h",
-        "stack_frame.h",
-    ],
+    name = "source_map_resolver",
+    srcs = ["source_map_resolver.cc"],
+    hdrs = ["source_map_resolver.h"],
     deps = [
-        ":function",
-        ":module",
+        "//iree/base:flatbuffer_util",
         "//iree/base:status",
-        "//iree/hal:buffer_view",
+        "//iree/rt",
+        "//iree/schemas",
         "@com_google_absl//absl/strings",
-        "@com_google_absl//absl/types:span",
+        "@com_google_absl//absl/types:optional",
     ],
 )
 
diff --git a/iree/vm/CMakeLists.txt b/iree/vm/CMakeLists.txt
index 4a357f3..ab8c873 100644
--- a/iree/vm/CMakeLists.txt
+++ b/iree/vm/CMakeLists.txt
@@ -12,14 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 iree_cc_library(
   NAME
-    bytecode_printer
+    bytecode_disassembler
   SRCS
-    "bytecode_printer.cc"
+    "bytecode_disassembler.cc"
   HDRS
-    "bytecode_printer.h"
+    "bytecode_disassembler.h"
   DEPS
     absl::core_headers
     absl::inlined_vector
@@ -28,18 +27,34 @@
     iree::base::status
     iree::schemas
     iree::schemas::bytecode::bytecode_v0
+    iree::rt
     iree::vm::bytecode_util
-    iree::vm::executable_table
-    iree::vm::function_table
-    iree::vm::module
     iree::vm::opcode_info
-    iree::vm::source_map
+    iree::vm::source_map_resolver
     iree::vm::type
   PUBLIC
 )
 
 iree_cc_library(
   NAME
+    bytecode_module
+  SRCS
+    "bytecode_module.cc"
+  HDRS
+    "bytecode_module.h"
+  DEPS
+    absl::memory
+    iree::base::flatbuffer_util
+    iree::base::status
+    iree::rt
+    iree::schemas
+    iree::vm::bytecode_disassembler
+    iree::vm::source_map_resolver
+  PUBLIC
+)
+
+iree_cc_library(
+  NAME
     bytecode_reader
   SRCS
     "bytecode_reader.cc"
@@ -52,9 +67,9 @@
     iree::base::status
     iree::hal::buffer_view
     iree::hal::heap_buffer
+    iree::rt
     iree::schemas::bytecode::bytecode_v0
-    iree::vm::function
-    iree::vm::stack
+    iree::vm::bytecode_module
     iree::vm::type
   PUBLIC
 )
@@ -115,137 +130,6 @@
 
 iree_cc_library(
   NAME
-    context
-  SRCS
-    "context.cc"
-  HDRS
-    "context.h"
-  DEPS
-    absl::strings
-    absl::span
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::vm::function
-    iree::vm::module
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    executable_table
-  SRCS
-    "executable_table.cc"
-  HDRS
-    "executable_table.h"
-  DEPS
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::schemas
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    fiber_state
-  SRCS
-    "fiber_state.cc"
-  HDRS
-    "fiber_state.h"
-  DEPS
-    absl::strings
-    absl::span
-    iree::base::status
-    iree::vm::instance
-    iree::vm::stack
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    function
-  SRCS
-    "function.cc"
-  HDRS
-    "function.h"
-  DEPS
-    absl::strings
-    absl::span
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::hal::buffer_view
-    iree::schemas
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    function_table
-  SRCS
-    "function_table.cc"
-  HDRS
-    "function_table.h"
-  DEPS
-    absl::flat_hash_map
-    absl::strings
-    absl::span
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::schemas
-    iree::vm::function
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    instance
-  SRCS
-    "instance.cc"
-  HDRS
-    "instance.h"
-  DEPS
-    absl::memory
-    iree::base::source_location
-    iree::base::status
-    iree::hal::device_manager
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    module
-  SRCS
-    "module.cc"
-  HDRS
-    "module.h"
-  DEPS
-    absl::memory
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::schemas
-    iree::vm::executable_table
-    iree::vm::function_table
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
-    module_printer
-  SRCS
-    "module_printer.cc"
-  HDRS
-    "module_printer.h"
-  DEPS
-    iree::base::bitfield
-    iree::base::status
-    iree::vm::bytecode_printer
-    iree::vm::module
-    iree::vm::opcode_info
-    iree::vm::source_map
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
     opcode_info
   HDRS
     "opcode_info.h"
@@ -259,28 +143,6 @@
 
 iree_cc_library(
   NAME
-    sequencer_context
-  SRCS
-    "sequencer_context.cc"
-  HDRS
-    "sequencer_context.h"
-  DEPS
-    absl::strings
-    absl::span
-    iree::base::flatbuffer_util
-    iree::base::status
-    iree::hal::buffer_view
-    iree::vm::context
-    iree::vm::fiber_state
-    iree::vm::function
-    iree::vm::instance
-    iree::vm::module
-    iree::vm::sequencer_dispatch
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
     sequencer_dispatch
   SRCS
     "sequencer_dispatch.cc"
@@ -300,53 +162,53 @@
     iree::hal::device
     iree::hal::device_placement
     iree::hal::heap_buffer
+    iree::rt
     iree::schemas::bytecode::sequencer_bytecode_v0
+    iree::vm::bytecode_module
     iree::vm::bytecode_reader
     iree::vm::bytecode_tables_sequencer
     iree::vm::bytecode_util
-    iree::vm::function
     iree::vm::opcode_info
-    iree::vm::stack
   PUBLIC
 )
 
 iree_cc_library(
   NAME
-    source_map
+    sequencer_module
   SRCS
-    "source_map.cc"
+    "sequencer_module.cc"
   HDRS
-    "source_map.h"
+    "sequencer_module.h"
+  DEPS
+    absl::core_headers
+    iree::base::status
+    iree::hal::buffer_view
+    iree::rt
+    iree::schemas::bytecode::sequencer_bytecode_v0
+    iree::vm::bytecode_module
+    iree::vm::sequencer_dispatch
+  PUBLIC
+)
+
+iree_cc_library(
+  NAME
+    source_map_resolver
+  SRCS
+    "source_map_resolver.cc"
+  HDRS
+    "source_map_resolver.h"
   DEPS
     absl::strings
     absl::optional
     iree::base::flatbuffer_util
     iree::base::status
+    iree::rt
     iree::schemas
   PUBLIC
 )
 
 iree_cc_library(
   NAME
-    stack
-  SRCS
-    "stack.cc"
-    "stack_frame.cc"
-  HDRS
-    "stack.h"
-    "stack_frame.h"
-  DEPS
-    absl::strings
-    absl::span
-    iree::base::status
-    iree::hal::buffer_view
-    iree::vm::function
-    iree::vm::module
-  PUBLIC
-)
-
-iree_cc_library(
-  NAME
     type
   SRCS
     "type.cc"
diff --git a/iree/vm/bytecode_printer.cc b/iree/vm/bytecode_disassembler.cc
similarity index 73%
rename from iree/vm/bytecode_printer.cc
rename to iree/vm/bytecode_disassembler.cc
index 136d257..4868792 100644
--- a/iree/vm/bytecode_printer.cc
+++ b/iree/vm/bytecode_disassembler.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "iree/vm/bytecode_printer.h"
+#include "iree/vm/bytecode_disassembler.h"
 
 #include <iomanip>
 #include <sstream>
@@ -25,8 +25,8 @@
 #include "iree/base/status.h"
 #include "iree/schemas/bytecode/bytecode_v0.h"
 #include "iree/schemas/source_map_def_generated.h"
+#include "iree/vm/bytecode_module.h"
 #include "iree/vm/bytecode_util.h"
-#include "iree/vm/module.h"
 #include "iree/vm/type.h"
 
 namespace iree {
@@ -34,8 +34,10 @@
 
 namespace {
 
+using ::iree::rt::SourceOffset;
+
 template <typename T>
-StatusOr<T> ReadValue(absl::Span<const uint8_t> data, int* offset) {
+StatusOr<T> ReadValue(absl::Span<const uint8_t> data, SourceOffset* offset) {
   if (*offset + sizeof(T) > data.size()) {
     return OutOfRangeErrorBuilder(IREE_LOC) << "Bytecode data underrun";
   }
@@ -44,16 +46,19 @@
   return value;
 }
 
-StatusOr<const Type> ReadType(absl::Span<const uint8_t> data, int* offset) {
+StatusOr<const Type> ReadType(absl::Span<const uint8_t> data,
+                              SourceOffset* offset) {
   ASSIGN_OR_RETURN(uint8_t type_index, ReadValue<uint8_t>(data, offset));
   return Type::FromTypeIndex(type_index);
 }
 
-StatusOr<uint8_t> ReadCount(absl::Span<const uint8_t> data, int* offset) {
+StatusOr<uint8_t> ReadCount(absl::Span<const uint8_t> data,
+                            SourceOffset* offset) {
   return ReadValue<uint8_t>(data, offset);
 }
 
-StatusOr<uint16_t> ReadValueSlot(absl::Span<const uint8_t> data, int* offset) {
+StatusOr<uint16_t> ReadValueSlot(absl::Span<const uint8_t> data,
+                                 SourceOffset* offset) {
   return ReadValue<uint16_t>(data, offset);
 }
 
@@ -103,55 +108,30 @@
 
 }  // namespace
 
-// static
-std::string BytecodePrinter::ToString(
-    OpcodeTable opcode_table, const FunctionTable& function_table,
-    const ExecutableTable& executable_table,
-    const SourceMapResolver& source_map_resolver,
-    const BytecodeDef& bytecode_def) {
-  BytecodePrinter printer(opcode_table, function_table, executable_table,
-                          source_map_resolver);
-  auto result = printer.Print(bytecode_def);
-  if (!result.ok()) {
-    return result.status().ToString();
-  }
-  return result.ValueOrDie();
-}
+StatusOr<std::vector<rt::Instruction>>
+BytecodeDisassembler::DisassembleInstructions(const rt::Function& function,
+                                              SourceOffset offset,
+                                              int32_t instruction_count) const {
+  std::vector<rt::Instruction> instructions;
 
-StatusOr<std::string> BytecodePrinter::Print(
-    const BytecodeDef& bytecode_def) const {
-  std::ostringstream stream;
-  RETURN_IF_ERROR(PrintToStream(bytecode_def, &stream)) << stream.str();
-  return stream.str();
-}
-
-Status BytecodePrinter::PrintToStream(const BytecodeDef& bytecode_def,
-                                      std::ostream* stream) const {
-  if (!bytecode_def.contents()) {
-    return OkStatus();
+  ASSIGN_OR_RETURN(
+      auto* function_def,
+      static_cast<const BytecodeModule*>(function.module())
+          ->GetFunctionDef(function.linkage(), function.ordinal()));
+  auto* bytecode_def = function_def->bytecode();
+  if (!bytecode_def) {
+    return UnavailableErrorBuilder(IREE_LOC) << "Function contains no body";
   }
   auto data = absl::MakeSpan(
-      reinterpret_cast<const uint8_t*>(bytecode_def.contents()->data()),
-      bytecode_def.contents()->size());
-  return PrintToStream(data, stream);
-}
+      reinterpret_cast<const uint8_t*>(bytecode_def->contents()->data()),
+      bytecode_def->contents()->size());
 
-Status BytecodePrinter::PrintToStream(absl::Span<const uint8_t> data,
-                                      std::ostream* stream) const {
   // TODO(benvanik): scan and find all branch offsets to insert labels
 
-  int offset = 0;
-  absl::optional<SourceLocation> previous_location;
-  while (offset < data.length()) {
-    auto source_location = source_map_resolver_.ResolveBytecodeOffset(offset);
-    if (source_location.has_value()) {
-      if (previous_location != source_location) {
-        *stream << std::setw(10) << "; " << source_location.value() << "\n";
-      }
-      previous_location = source_location;
-    }
-
-    *stream << std::setw(6) << offset << ": ";
+  while (offset < data.length() && instructions.size() < instruction_count) {
+    instructions.push_back({});
+    auto& instruction = instructions.back();
+    instruction.offset = offset;
 
     uint8_t opcode = data[offset++];
     const auto& opcode_info = GetOpcodeInfo(opcode_table_, opcode);
@@ -161,6 +141,8 @@
     }
     int payload_offset = offset;
 
+    std::ostringstream stream;
+
     // Print out return values, if any.
     int base_result_index = 0;
     int printed_result_count = 0;
@@ -168,7 +150,7 @@
          ++i) {
       if (opcode_info.operands[i] == OperandEncoding::kNone) break;
       if (printed_result_count > 0) {
-        *stream << ", ";
+        stream << ", ";
       }
       switch (opcode_info.operands[i]) {
         default:
@@ -193,20 +175,20 @@
         case OperandEncoding::kResultSlot: {
           ++printed_result_count;
           ASSIGN_OR_RETURN(uint16_t slot_ordinal, ReadValueSlot(data, &offset));
-          *stream << "%" << slot_ordinal;
+          stream << "%" << slot_ordinal;
           break;
         }
         case OperandEncoding::kVariadicResultSlots: {
           ++printed_result_count;
-          *stream << "[";
+          stream << "[";
           ASSIGN_OR_RETURN(int count, ReadCount(data, &offset));
           for (int j = 0; j < count; ++j) {
             ASSIGN_OR_RETURN(uint16_t slot_ordinal,
                              ReadValueSlot(data, &offset));
-            if (j > 0) *stream << ", ";
-            *stream << "%" << slot_ordinal;
+            if (j > 0) stream << ", ";
+            stream << "%" << slot_ordinal;
           }
-          *stream << "]";
+          stream << "]";
           break;
         }
         case OperandEncoding::kVariadicTransferSlots: {
@@ -268,11 +250,11 @@
       }
     }
     if (printed_result_count > 0) {
-      *stream << " = ";
+      stream << " = ";
     }
     offset = payload_offset;
 
-    *stream << opcode_info.mnemonic;
+    stream << opcode_info.mnemonic;
 
     // Print out operands.
     int base_operand_index = 0;
@@ -283,9 +265,9 @@
       if (opcode_info.operands[i] != OperandEncoding::kResultSlot &&
           opcode_info.operands[i] != OperandEncoding::kVariadicResultSlots) {
         if (i == base_operand_index) {
-          *stream << " ";
+          stream << " ";
         } else if (printed_operand_count > 0) {
-          *stream << ", ";
+          stream << ", ";
         }
       }
       switch (opcode_info.operands[i]) {
@@ -298,41 +280,41 @@
         case OperandEncoding::kInputSlot: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(uint16_t slot_ordinal, ReadValueSlot(data, &offset));
-          *stream << "%" << slot_ordinal;
+          stream << "%" << slot_ordinal;
           break;
         }
         case OperandEncoding::kVariadicInputSlots: {
           ++printed_operand_count;
-          *stream << "[";
+          stream << "[";
           ASSIGN_OR_RETURN(int count, ReadCount(data, &offset));
           for (int j = 0; j < count; ++j) {
             ASSIGN_OR_RETURN(uint16_t slot_ordinal,
                              ReadValueSlot(data, &offset));
-            if (j > 0) *stream << ", ";
-            *stream << "%" << slot_ordinal;
+            if (j > 0) stream << ", ";
+            stream << "%" << slot_ordinal;
           }
-          *stream << "]";
+          stream << "]";
           break;
         }
         case OperandEncoding::kOutputSlot: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(uint16_t slot_ordinal, ReadValueSlot(data, &offset));
-          *stream << "&"
-                  << "%" << slot_ordinal;
+          stream << "&"
+                 << "%" << slot_ordinal;
           break;
         }
         case OperandEncoding::kVariadicOutputSlots: {
           ++printed_operand_count;
-          *stream << "[";
+          stream << "[";
           ASSIGN_OR_RETURN(int count, ReadCount(data, &offset));
           for (int j = 0; j < count; ++j) {
             ASSIGN_OR_RETURN(uint16_t slot_ordinal,
                              ReadValueSlot(data, &offset));
-            if (j > 0) *stream << ", ";
-            *stream << "&"
-                    << "%" << slot_ordinal;
+            if (j > 0) stream << ", ";
+            stream << "&"
+                   << "%" << slot_ordinal;
           }
-          *stream << "]";
+          stream << "]";
           break;
         }
         case OperandEncoding::kResultSlot: {
@@ -348,17 +330,17 @@
         }
         case OperandEncoding::kVariadicTransferSlots: {
           ++printed_operand_count;
-          *stream << "[";
+          stream << "[";
           ASSIGN_OR_RETURN(int count, ReadCount(data, &offset));
           for (int j = 0; j < count; ++j) {
             ASSIGN_OR_RETURN(uint16_t src_slot_ordinal,
                              ReadValueSlot(data, &offset));
             ASSIGN_OR_RETURN(uint16_t dst_slot_ordinal,
                              ReadValueSlot(data, &offset));
-            if (j > 0) *stream << ", ";
-            *stream << "%" << src_slot_ordinal << "=>%" << dst_slot_ordinal;
+            if (j > 0) stream << ", ";
+            stream << "%" << src_slot_ordinal << "=>%" << dst_slot_ordinal;
           }
-          *stream << "]";
+          stream << "]";
           break;
         }
         case OperandEncoding::kConstant: {
@@ -374,7 +356,7 @@
           }
           ASSIGN_OR_RETURN(auto encoding,
                            ReadValue<ConstantEncoding>(data, &offset));
-          *stream << ConstantEncodingToString(encoding);
+          stream << ConstantEncodingToString(encoding);
           int serialized_element_count = 1;
           switch (encoding) {
             case ConstantEncoding::kDense:
@@ -388,27 +370,29 @@
                      << "Unimplemented constant encoding "
                      << static_cast<int>(encoding);
           }
-          *stream << " buffer_view<";
+          stream << " buffer_view<";
           if (!shape.empty()) {
-            *stream << absl::StrJoin(shape, "x") << "x";
+            stream << absl::StrJoin(shape, "x") << "x";
           }
-          *stream << type << ">{";
+          stream << type << ">{";
           size_t element_size = type.element_size();
           auto bytes = data.subspan(
               offset, std::min(serialized_element_count, 1024) * element_size);
-          *stream << ConstantToString(type, bytes);
-          if (serialized_element_count > 1024) *stream << "...";
+          stream << ConstantToString(type, bytes);
+          if (serialized_element_count > 1024) stream << "...";
           offset += serialized_element_count * element_size;
-          *stream << "}";
+          stream << "}";
           break;
         }
         case OperandEncoding::kFunctionOrdinal: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto function_ordinal,
                            ReadValue<uint32_t>(data, &offset));
-          ASSIGN_OR_RETURN(auto function,
-                           function_table_.LookupFunction(function_ordinal));
-          *stream << "@" << function_ordinal << " " << function.name();
+          ASSIGN_OR_RETURN(
+              auto target_function,
+              function.module()->LookupFunctionByOrdinal(
+                  rt::Function::Linkage::kInternal, function_ordinal));
+          stream << "@" << function_ordinal << " " << target_function.name();
           break;
         }
         case OperandEncoding::kDispatchOrdinal: {
@@ -418,88 +402,80 @@
           ASSIGN_OR_RETURN(auto export_ordinal,
                            ReadValue<uint16_t>(data, &offset));
           // TODO(benvanik): lookup in executable table.
-          *stream << "@" << dispatch_ordinal << ":" << export_ordinal;
+          stream << "@" << dispatch_ordinal << ":" << export_ordinal;
           break;
         }
         case OperandEncoding::kImportOrdinal: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto import_ordinal,
                            ReadValue<uint32_t>(data, &offset));
-          ASSIGN_OR_RETURN(auto* function,
-                           function_table_.LookupImport(import_ordinal));
-          *stream << "@i" << import_ordinal << " ";
-          switch (function->link_type()) {
-            default:
-              *stream << "??";
-              break;
-            case ImportFunction::LinkType::kNativeFunction:
-              *stream << "<native>";
-              break;
-            case ImportFunction::LinkType::kModule:
-              *stream << function->linked_function().module().name() << ":"
-                      << function->linked_function().name();
-              break;
-          }
+          ASSIGN_OR_RETURN(auto target_function,
+                           function.module()->LookupFunctionByOrdinal(
+                               rt::Function::Linkage::kImport, import_ordinal));
+          stream << "@i" << import_ordinal << " " << target_function.name();
           break;
         }
         case OperandEncoding::kBlockOffset: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(uint32_t block_offset,
                            ReadValue<uint32_t>(data, &offset));
-          *stream << ":" << block_offset;
+          stream << ":" << block_offset;
           break;
         }
         case OperandEncoding::kTypeIndex: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto type, ReadType(data, &offset));
-          *stream << type;
+          stream << type;
           break;
         }
         case OperandEncoding::kIndex: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto index, ReadValue<int32_t>(data, &offset));
-          *stream << "#" << index;
+          stream << "#" << index;
           break;
         }
         case OperandEncoding::kIndexList: {
           ++printed_operand_count;
-          *stream << "{";
+          stream << "{";
           ASSIGN_OR_RETURN(int count, ReadCount(data, &offset));
           for (int j = 0; j < count; ++j) {
             ASSIGN_OR_RETURN(auto dim, ReadValue<int32_t>(data, &offset));
-            if (j > 0) *stream << ",";
-            *stream << dim;
+            if (j > 0) stream << ",";
+            stream << dim;
           }
-          *stream << "}";
+          stream << "}";
           break;
         }
         case OperandEncoding::kCmpIPredicate: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto predicate_value,
                            ReadValue<uint8_t>(data, &offset));
-          *stream << "<"
-                  << PredicateToString(
-                         static_cast<CmpIPredicate>(predicate_value))
-                  << ">";
+          stream << "<"
+                 << PredicateToString(
+                        static_cast<CmpIPredicate>(predicate_value))
+                 << ">";
           break;
         }
         case OperandEncoding::kCmpFPredicate: {
           ++printed_operand_count;
           ASSIGN_OR_RETURN(auto predicate_value,
                            ReadValue<uint8_t>(data, &offset));
-          *stream << "<"
-                  << PredicateToString(
-                         static_cast<CmpFPredicate>(predicate_value))
-                  << ">";
+          stream << "<"
+                 << PredicateToString(
+                        static_cast<CmpFPredicate>(predicate_value))
+                 << ">";
           break;
         }
       }
     }
 
-    *stream << "\n";
+    stream << "\n";
+
+    instruction.long_text = stream.str();
+    instruction.short_text = instruction.long_text;
   }
 
-  return OkStatus();
+  return instructions;
 }
 
 }  // namespace vm
diff --git a/iree/vm/bytecode_disassembler.h b/iree/vm/bytecode_disassembler.h
new file mode 100644
index 0000000..633e290
--- /dev/null
+++ b/iree/vm/bytecode_disassembler.h
@@ -0,0 +1,46 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_VM_BYTECODE_DISASSEMBLER_H_
+#define IREE_VM_BYTECODE_DISASSEMBLER_H_
+
+#include <ostream>
+
+#include "iree/base/status.h"
+#include "iree/rt/disassembler.h"
+#include "iree/schemas/bytecode_def_generated.h"
+#include "iree/schemas/source_map_def_generated.h"
+#include "iree/vm/opcode_info.h"
+
+namespace iree {
+namespace vm {
+
+// Disassembles bytecode with a specific op set to text.
+class BytecodeDisassembler final : public rt::Disassembler {
+ public:
+  explicit BytecodeDisassembler(OpcodeTable opcode_table)
+      : opcode_table_(opcode_table) {}
+
+  StatusOr<std::vector<rt::Instruction>> DisassembleInstructions(
+      const rt::Function& function, rt::SourceOffset offset,
+      int32_t instruction_count) const override;
+
+ private:
+  OpcodeTable opcode_table_;
+};
+
+}  // namespace vm
+}  // namespace iree
+
+#endif  // IREE_VM_BYTECODE_DISASSEMBLER_H_
diff --git a/iree/vm/bytecode_module.cc b/iree/vm/bytecode_module.cc
new file mode 100644
index 0000000..7812cb6
--- /dev/null
+++ b/iree/vm/bytecode_module.cc
@@ -0,0 +1,310 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "iree/vm/bytecode_module.h"
+
+#include "absl/memory/memory.h"
+#include "iree/base/status.h"
+#include "iree/base/tracing.h"
+#include "iree/hal/buffer_view.h"
+#include "iree/vm/bytecode_disassembler.h"
+
+namespace iree {
+namespace vm {
+
+namespace {
+
+using ::iree::hal::BufferView;
+using ::iree::rt::Function;
+using ::iree::rt::FunctionSignature;
+using ::iree::rt::Module;
+using ::iree::rt::ModuleSignature;
+
+Status ValidateElementSize(int element_bit_width,
+                           const ElementTypeDef& expected_element_type) {
+  switch (expected_element_type.type_union_type()) {
+    case ElementTypeDefUnion::FloatTypeDef: {
+      auto expected_bit_width =
+          expected_element_type.type_union_as_FloatTypeDef()->width();
+      if (element_bit_width != expected_bit_width) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Has element bit width " << element_bit_width
+               << " but expected " << expected_bit_width;
+      }
+      return OkStatus();
+    }
+    case ElementTypeDefUnion::IntegerTypeDef: {
+      auto expected_bit_width =
+          expected_element_type.type_union_as_IntegerTypeDef()->width();
+      if (element_bit_width != expected_bit_width) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Has element bit width " << element_bit_width
+               << " but expected " << expected_bit_width;
+      }
+      return OkStatus();
+    }
+    case ElementTypeDefUnion::UnknownTypeDef:
+    case ElementTypeDefUnion::NONE: {
+    }
+  }
+  return InvalidArgumentErrorBuilder(IREE_LOC)
+         << "Defined type has unsupported element type "
+         << EnumNameElementTypeDefUnion(
+                expected_element_type.type_union_type());
+}
+
+Status ValidateTypeStructure(const FunctionTypeDef& type_def) {
+  // Ensure all fields are populated.
+  return OkStatus();
+}
+
+Status ValidateFunctionTableStructure(
+    const FunctionTableDef& function_table_def) {
+  if (!function_table_def.functions()) {
+    return InvalidArgumentErrorBuilder(IREE_LOC)
+           << "Function table is missing the function listing";
+  }
+
+  // All functions must contain a valid type.
+  const auto& functions = *function_table_def.functions();
+  for (int i = 0; i < functions.size(); ++i) {
+    const auto* function = functions[i];
+    if (!function) {
+      return InvalidArgumentErrorBuilder(IREE_LOC)
+             << "Function ordinal " << i << " is missing its contents";
+    }
+    if (!function->type()) {
+      return InvalidArgumentErrorBuilder(IREE_LOC)
+             << "Function ordinal " << i << " is missing its type";
+    }
+    RETURN_IF_ERROR(ValidateTypeStructure(*function->type()));
+  }
+
+  // Imports must also have a name (that we can use to resolve it).
+  if (function_table_def.imports()) {
+    const auto& imports = *function_table_def.imports();
+    for (int i = 0; i < imports.size(); ++i) {
+      int function_index = imports[i];
+      if (!functions[function_index]->name()) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Import ordinal " << i << " is missing its contents";
+      }
+    }
+  }
+
+  // Exports must also have a name (that others will use to look it up).
+  if (function_table_def.exports()) {
+    const auto& exports = *function_table_def.exports();
+    for (int i = 0; i < exports.size(); ++i) {
+      int function_index = exports[i];
+      if (!functions[function_index]->name()) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Export ordinal " << i << " is missing its contents";
+      }
+    }
+  }
+
+  return OkStatus();
+}
+
+Status ValidateExecutableTableStructure(
+    const ExecutableTableDef& executable_table_def) {
+  if (!executable_table_def.multi_arch_executables()) {
+    // May have sequencer only fns. Fine to not have dispatchable executables.
+    return OkStatus();
+  }
+
+  // All fat executables need at least one device-specific executable.
+  const auto& multi_arch_executables =
+      *executable_table_def.multi_arch_executables();
+  for (int i = 0; i < multi_arch_executables.size(); ++i) {
+    const auto* multi_arch_executable = multi_arch_executables[i];
+    if (!multi_arch_executable || !multi_arch_executable->executables() ||
+        multi_arch_executable->executables()->size() == 0) {
+      return InvalidArgumentErrorBuilder(IREE_LOC)
+             << "Multi-arch executable ordinal " << i
+             << " is missing its contents";
+    }
+  }
+
+  return OkStatus();
+}
+
+}  // namespace
+
+// static
+Status BytecodeModule::ValidateStructure(const ModuleDef& module_def) {
+  IREE_TRACE_SCOPE0("BytecodeModule::ValidateStructure");
+
+  // Must have a function table.
+  if (module_def.function_table()) {
+    RETURN_IF_ERROR(
+        ValidateFunctionTableStructure(*module_def.function_table()));
+  } else {
+    return InvalidArgumentErrorBuilder(IREE_LOC)
+           << "ModuleDef is missing a function table";
+  }
+
+  // Must have an executable table.
+  if (module_def.executable_table()) {
+    RETURN_IF_ERROR(
+        ValidateExecutableTableStructure(*module_def.executable_table()));
+  } else {
+    return InvalidArgumentErrorBuilder(IREE_LOC)
+           << "ModuleDef is missing an executable table";
+  }
+
+  return OkStatus();
+}
+
+BytecodeModule::BytecodeModule(std::unique_ptr<ModuleFile> module_file,
+                               OpcodeTable opcode_table)
+    : module_file_(std::move(module_file)),
+      module_def_(*module_file_->root()),
+      source_resolver_(SourceMapResolver::FromModule(module_def_)),
+      disassembler_(absl::make_unique<BytecodeDisassembler>(opcode_table)) {}
+
+BytecodeModule::~BytecodeModule() = default;
+
+const ModuleSignature BytecodeModule::signature() const {
+  return ModuleSignature(function_table_def().imports()->size(),
+                         function_table_def().exports()->size(),
+                         function_table_def().functions()->size(), 0);
+}
+
+std::string BytecodeModule::DebugStringShort() const {
+  return std::string(name());
+}
+
+StatusOr<int32_t> BytecodeModule::MapFunctionOrdinal(Function::Linkage linkage,
+                                                     int32_t ordinal) const {
+  const auto& function_table = function_table_def();
+  switch (linkage) {
+    case Function::Linkage::kImport:
+      if (ordinal < 0 || ordinal >= function_table.imports()->size()) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Import ordinal " << ordinal
+               << " is outside the valid range [0, "
+               << function_table.imports()->size() << ")";
+      }
+      ordinal = function_table.imports()->Get(ordinal);
+      break;
+    case Function::Linkage::kExport:
+      if (ordinal < 0 || ordinal >= function_table.exports()->size()) {
+        return InvalidArgumentErrorBuilder(IREE_LOC)
+               << "Export ordinal " << ordinal
+               << " is outside the valid range [0, "
+               << function_table.exports()->size() << ")";
+      }
+      ordinal = function_table.exports()->Get(ordinal);
+      break;
+    default:
+      break;
+  }
+  if (ordinal < 0 || ordinal >= function_table.functions()->size()) {
+    return OutOfRangeErrorBuilder(IREE_LOC)
+           << "Function ordinal " << ordinal
+           << " is outside the valid range [0, "
+           << function_table.functions()->size() << ")";
+  }
+  return ordinal;
+}
+
+StatusOr<const Function> BytecodeModule::LookupFunctionByOrdinal(
+    Function::Linkage linkage, int32_t ordinal) const {
+  ASSIGN_OR_RETURN(ordinal, MapFunctionOrdinal(linkage, ordinal));
+  return Function(this, Function::Linkage::kInternal, ordinal);
+}
+
+StatusOr<const Function> BytecodeModule::LookupFunctionByName(
+    Function::Linkage linkage, absl::string_view name) const {
+  const auto& functions = *function_table_def().functions();
+  for (int i = 0; i < functions.size(); ++i) {
+    const auto* function_def = functions.Get(i);
+    if (WrapString(function_def->name()) == name) {
+      return LookupFunctionByOrdinal(Function::Linkage::kInternal, i);
+    }
+  }
+  return NotFoundErrorBuilder(IREE_LOC)
+         << "Function '" << name
+         << "' not found in function table (or names have been stripped)";
+}
+
+StatusOr<absl::string_view> BytecodeModule::GetFunctionName(
+    Function::Linkage linkage, int32_t ordinal) const {
+  ASSIGN_OR_RETURN(ordinal, MapFunctionOrdinal(linkage, ordinal));
+  const auto* function_def = function_table_def().functions()->Get(ordinal);
+  return WrapString(function_def->name());
+}
+
+StatusOr<const FunctionSignature> BytecodeModule::GetFunctionSignature(
+    Function::Linkage linkage, int32_t ordinal) const {
+  ASSIGN_OR_RETURN(ordinal, MapFunctionOrdinal(linkage, ordinal));
+  const auto* function_def = function_table_def().functions()->Get(ordinal);
+  const auto* type_def = function_def->type();
+  return FunctionSignature(
+      type_def->inputs() ? type_def->inputs()->size() : 0,
+      type_def->results() ? type_def->results()->size() : 0);
+}
+
+StatusOr<const FunctionDef*> BytecodeModule::GetFunctionDef(
+    rt::Function::Linkage linkage, int32_t ordinal) const {
+  ASSIGN_OR_RETURN(ordinal, MapFunctionOrdinal(linkage, ordinal));
+  const auto& function_defs = *function_table_def().functions();
+  if (ordinal >= function_defs.size()) {
+    return OutOfRangeErrorBuilder(IREE_LOC)
+           << "Internal function ordinal " << ordinal
+           << " out of range of table (" << function_defs.size() << ")";
+  }
+  return function_defs.Get(ordinal);
+}
+
+StatusOr<const MultiArchExecutableDef*>
+BytecodeModule::LookupMultiArchExecutable(int executable_ordinal) const {
+  if (executable_ordinal < 0 ||
+      executable_ordinal >=
+          executable_table_def().multi_arch_executables()->size()) {
+    return InvalidArgumentErrorBuilder(IREE_LOC)
+           << "Invalid multi-arch executable ordinal " << executable_ordinal;
+  }
+  return executable_table_def().multi_arch_executables()->Get(
+      executable_ordinal);
+}
+
+// static
+Status BytecodeModule::ValidateArgType(const BufferView& arg,
+                                       const MemRefTypeDef& expected_type) {
+  RETURN_IF_ERROR(
+      ValidateElementSize(arg.element_size * 8, *expected_type.element_type()));
+
+  auto expected_shape = expected_type.shape();
+  if (arg.shape.size() != expected_shape->size()) {
+    return InvalidArgumentErrorBuilder(IREE_LOC)
+           << "Argument should have rank " << expected_shape->size()
+           << " but has rank " << arg.shape.size();
+  }
+  for (int i = 0; i < expected_shape->size(); ++i) {
+    auto dim_size = arg.shape[i];
+    auto expected_dim_size = expected_shape->Get(i);
+    if (dim_size != expected_dim_size) {
+      return InvalidArgumentErrorBuilder(IREE_LOC)
+             << "Argument dimension " << i << " should have size "
+             << expected_dim_size << " but has size " << dim_size;
+    }
+  }
+  return OkStatus();
+}
+
+}  // namespace vm
+}  // namespace iree
diff --git a/iree/vm/bytecode_module.h b/iree/vm/bytecode_module.h
new file mode 100644
index 0000000..36d034e
--- /dev/null
+++ b/iree/vm/bytecode_module.h
@@ -0,0 +1,103 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_VM_BYTECODE_MODULE_H_
+#define IREE_VM_BYTECODE_MODULE_H_
+
+#include <memory>
+
+#include "iree/base/flatbuffer_util.h"
+#include "iree/rt/function.h"
+#include "iree/rt/module.h"
+#include "iree/schemas/executable_table_def_generated.h"
+#include "iree/schemas/function_table_def_generated.h"
+#include "iree/schemas/module_def_generated.h"
+#include "iree/vm/opcode_info.h"
+#include "iree/vm/source_map_resolver.h"
+
+namespace iree {
+namespace vm {
+
+using ModuleFile = FlatBufferFile<ModuleDef>;
+
+// A loaded bytecode module backed by a FlatBuffer.
+class BytecodeModule : public rt::Module {
+ public:
+  static Status ValidateStructure(const ModuleDef& module_def);
+
+  ~BytecodeModule() override;
+
+  const ModuleDef& def() const { return module_def_; }
+  const FunctionTableDef& function_table_def() const {
+    return *module_def_.function_table();
+  }
+  const ExecutableTableDef& executable_table_def() const {
+    return *module_def_.executable_table();
+  }
+
+  absl::string_view name() const override {
+    return WrapString(module_def_.name());
+  }
+
+  const rt::ModuleSignature signature() const override;
+
+  rt::SourceResolver* source_resolver() const override {
+    return &source_resolver_;
+  }
+
+  rt::Disassembler* disassembler() const override {
+    return disassembler_.get();
+  }
+
+  std::string DebugStringShort() const override;
+
+  StatusOr<const rt::Function> LookupFunctionByOrdinal(
+      rt::Function::Linkage linkage, int32_t ordinal) const override;
+
+  StatusOr<const rt::Function> LookupFunctionByName(
+      rt::Function::Linkage linkage, absl::string_view name) const override;
+
+  StatusOr<absl::string_view> GetFunctionName(rt::Function::Linkage linkage,
+                                              int32_t ordinal) const override;
+
+  StatusOr<const rt::FunctionSignature> GetFunctionSignature(
+      rt::Function::Linkage linkage, int32_t ordinal) const override;
+
+  StatusOr<const FunctionDef*> GetFunctionDef(rt::Function::Linkage linkage,
+                                              int32_t ordinal) const;
+
+  StatusOr<const MultiArchExecutableDef*> LookupMultiArchExecutable(
+      int executable_ordinal) const;
+
+ protected:
+  BytecodeModule(std::unique_ptr<ModuleFile> module_file,
+                 OpcodeTable opcode_table);
+
+  static Status ValidateArgType(const hal::BufferView& arg,
+                                const MemRefTypeDef& expected_type);
+
+ private:
+  StatusOr<int32_t> MapFunctionOrdinal(rt::Function::Linkage linkage,
+                                       int32_t ordinal) const;
+
+  std::unique_ptr<ModuleFile> module_file_;
+  const ModuleDef& module_def_;
+  mutable SourceMapResolver source_resolver_;
+  mutable std::unique_ptr<rt::Disassembler> disassembler_;
+};
+
+}  // namespace vm
+}  // namespace iree
+
+#endif  // IREE_VM_BYTECODE_MODULE_H_
diff --git a/iree/vm/bytecode_printer.h b/iree/vm/bytecode_printer.h
deleted file mode 100644
index 2f2cd5b..0000000
--- a/iree/vm/bytecode_printer.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_BYTECODE_PRINTER_H_
-#define IREE_VM_BYTECODE_PRINTER_H_
-
-#include <ostream>
-
-#include "iree/base/status.h"
-#include "iree/schemas/bytecode_def_generated.h"
-#include "iree/schemas/source_map_def_generated.h"
-#include "iree/vm/executable_table.h"
-#include "iree/vm/function_table.h"
-#include "iree/vm/opcode_info.h"
-#include "iree/vm/source_map.h"
-
-namespace iree {
-namespace vm {
-
-// Prints bytecode in a text format to enable human-inspection.
-// Optionally can interleave original source location information if a SourceMap
-// is available.
-class BytecodePrinter {
- public:
-  static std::string ToString(OpcodeTable opcode_table,
-                              const FunctionTable& function_table,
-                              const ExecutableTable& executable_table,
-                              const SourceMapResolver& source_map_resolver,
-                              const BytecodeDef& bytecode_def);
-
-  explicit BytecodePrinter(OpcodeTable opcode_table,
-                           const FunctionTable& function_table,
-                           const ExecutableTable& executable_table,
-                           const SourceMapResolver& source_map_resolver)
-      : opcode_table_(opcode_table),
-        function_table_(function_table),
-        executable_table_(executable_table),
-        source_map_resolver_(source_map_resolver) {}
-
-  StatusOr<std::string> Print(const BytecodeDef& bytecode_def) const;
-
-  Status PrintToStream(const BytecodeDef& bytecode_def,
-                       std::ostream* stream) const;
-  Status PrintToStream(absl::Span<const uint8_t> data,
-                       std::ostream* stream) const;
-
- private:
-  OpcodeTable opcode_table_;
-  const FunctionTable& function_table_;
-  const ExecutableTable& executable_table_;
-  const SourceMapResolver& source_map_resolver_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_BYTECODE_PRINTER_H_
diff --git a/iree/vm/bytecode_reader.cc b/iree/vm/bytecode_reader.cc
index cd1e0bf..65e69f3 100644
--- a/iree/vm/bytecode_reader.cc
+++ b/iree/vm/bytecode_reader.cc
@@ -17,12 +17,16 @@
 #include "iree/base/shape.h"
 #include "iree/base/status.h"
 #include "iree/hal/heap_buffer.h"
+#include "iree/vm/bytecode_module.h"
 
 namespace iree {
 namespace vm {
 
 namespace {
+
 using ::iree::hal::BufferView;
+using ::iree::rt::StackFrame;
+
 }  // namespace
 
 StatusOr<const uint8_t*> BytecodeReader::AdvanceOffset() {
@@ -30,18 +34,10 @@
   // TODO(benvanik): make a flag and/or remove.
   DVLOG(1) << "dispatch(" << stack_frame_->function().name() << "@" << offset()
            << "): " << int(*bytecode_pc_);
-  for (int i = 0; i < locals_.size(); ++i) {
-    DVLOG(1) << "local[" << i << "] " << locals_[i].DebugStringShort();
+  for (int i = 0; i < registers_->buffer_views.size(); ++i) {
+    DVLOG(1) << "local[" << i << "] "
+             << registers_->buffer_views[i].DebugStringShort();
   }
-
-  if (breakpoint_table_) {
-    auto it = breakpoint_table_->find(offset());
-    if (it != breakpoint_table_->end()) {
-      // Breakpoint hit!
-      RETURN_IF_ERROR(it->second(*stack_));
-    }
-  }
-
   return bytecode_pc_++;
 }
 
@@ -128,29 +124,26 @@
 
   // Setup state pointers for faster dereferencing.
   const auto& function = new_stack_frame->function();
-  const auto& bytecode = *function.def().bytecode();
+  ASSIGN_OR_RETURN(
+      const auto* function_def,
+      static_cast<const BytecodeModule*>(function.module())
+          ->GetFunctionDef(function.linkage(), function.ordinal()));
+  const auto& bytecode = *function_def->bytecode();
   bytecode_base_ = bytecode.contents()->Data();
   bytecode_limit_ = bytecode_base_ + bytecode.contents()->size();
   bytecode_pc_ = bytecode_base_ + new_stack_frame->offset();
-  locals_ = new_stack_frame->mutable_locals();
-  // TODO(benvanik): reimplement breakpoints as bytecode rewriting.
-  int function_ordinal = function.module()
-                             .function_table()
-                             .LookupFunctionOrdinal(function)
-                             .ValueOrDie();
-  breakpoint_table_ =
-      function.module().function_table().GetFunctionBreakpointTable(
-          function_ordinal);
+  registers_ = new_stack_frame->mutable_registers();
   return OkStatus();
 }
 
 Status BytecodeReader::CopyInputsAndSwitchStackFrame(
     StackFrame* src_stack_frame, StackFrame* dst_stack_frame) {
-  ASSIGN_OR_RETURN(int32_t src_count, ReadCount());
-  for (int i = 0; i < src_count; ++i) {
+  ASSIGN_OR_RETURN(size_t src_count, ReadCount());
+  auto& dst_buffer_views = dst_stack_frame->mutable_registers()->buffer_views;
+  for (int i = 0; i < std::min(src_count, dst_buffer_views.size()); ++i) {
     ASSIGN_OR_RETURN(auto* src_local,
-                     ReadLocal(src_stack_frame->mutable_locals()));
-    *dst_stack_frame->mutable_local(i) = *src_local;
+                     ReadLocal(src_stack_frame->mutable_registers()));
+    dst_buffer_views[i] = *src_local;
   }
   return SwitchStackFrame(dst_stack_frame);
 }
@@ -162,7 +155,7 @@
   absl::InlinedVector<BufferView*, 8> src_locals(src_count);
   for (int i = 0; i < src_count; ++i) {
     ASSIGN_OR_RETURN(src_locals[i],
-                     ReadLocal(src_stack_frame->mutable_locals()));
+                     ReadLocal(src_stack_frame->mutable_registers()));
   }
   RETURN_IF_ERROR(SwitchStackFrame(dst_stack_frame));
   ASSIGN_OR_RETURN(int32_t dst_count, ReadCount());
@@ -173,7 +166,7 @@
   }
   for (int i = 0; i < dst_count; ++i) {
     ASSIGN_OR_RETURN(auto* dst_local,
-                     ReadLocal(dst_stack_frame->mutable_locals()));
+                     ReadLocal(dst_stack_frame->mutable_registers()));
     *dst_local = *src_locals[i];
   }
   return OkStatus();
@@ -183,9 +176,9 @@
   ASSIGN_OR_RETURN(int32_t count, ReadCount());
   for (int i = 0; i < count; ++i) {
     ASSIGN_OR_RETURN(auto* src_local,
-                     ReadLocal(stack_frame_->mutable_locals()));
+                     ReadLocal(stack_frame_->mutable_registers()));
     ASSIGN_OR_RETURN(auto* dst_local,
-                     ReadLocal(stack_frame_->mutable_locals()));
+                     ReadLocal(stack_frame_->mutable_registers()));
     *dst_local = *src_local;
   }
   return OkStatus();
diff --git a/iree/vm/bytecode_reader.h b/iree/vm/bytecode_reader.h
index 6ba8227..f2b85fd 100644
--- a/iree/vm/bytecode_reader.h
+++ b/iree/vm/bytecode_reader.h
@@ -19,10 +19,10 @@
 #include "absl/container/inlined_vector.h"
 #include "iree/base/status.h"
 #include "iree/hal/buffer_view.h"
+#include "iree/rt/context.h"
+#include "iree/rt/stack.h"
+#include "iree/rt/stack_frame.h"
 #include "iree/schemas/bytecode/bytecode_v0.h"
-#include "iree/vm/function.h"
-#include "iree/vm/stack.h"
-#include "iree/vm/stack_frame.h"
 #include "iree/vm/type.h"
 
 namespace iree {
@@ -30,19 +30,19 @@
 
 class BytecodeReader {
  public:
-  explicit BytecodeReader(Stack* stack) : stack_(stack) {}
+  explicit BytecodeReader(rt::Stack* stack) : stack_(stack) {}
 
   int offset() const { return static_cast<int>(bytecode_pc_ - bytecode_base_); }
 
   StatusOr<const uint8_t*> AdvanceOffset();
 
-  Status SwitchStackFrame(StackFrame* new_stack_frame);
+  Status SwitchStackFrame(rt::StackFrame* new_stack_frame);
   Status BranchToOffset(int32_t offset);
 
-  Status CopyInputsAndSwitchStackFrame(StackFrame* src_stack_frame,
-                                       StackFrame* dst_stack_frame);
-  Status CopyResultsAndSwitchStackFrame(StackFrame* src_stack_frame,
-                                        StackFrame* dst_stack_frame);
+  Status CopyInputsAndSwitchStackFrame(rt::StackFrame* src_stack_frame,
+                                       rt::StackFrame* dst_stack_frame);
+  Status CopyResultsAndSwitchStackFrame(rt::StackFrame* src_stack_frame,
+                                        rt::StackFrame* dst_stack_frame);
   Status CopySlots();
 
   StatusOr<hal::BufferView> ReadConstant();
@@ -56,32 +56,33 @@
     return Type::FromTypeIndex(type_index);
   }
 
-  ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<const Function> ReadFunction() {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<const rt::Function> ReadFunction() {
     ASSIGN_OR_RETURN(auto value, ReadValue<uint32_t>());
     const auto& module = stack_frame_->module();
-    return module.function_table().LookupFunction(value);
+    return module.LookupFunctionByOrdinal(rt::Function::Linkage::kInternal,
+                                          value);
   }
 
-  ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<const ImportFunction*>
+  ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<const rt::Function>
   ReadImportFunction() {
     ASSIGN_OR_RETURN(auto value, ReadValue<uint32_t>());
     const auto& module = stack_frame_->module();
-    return module.function_table().LookupImport(value);
+    return stack_->context()->ResolveImport(&module, value);
   }
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<hal::BufferView*> ReadLocal(
-      absl::Span<hal::BufferView> locals) {
+      rt::Registers* registers) {
     ASSIGN_OR_RETURN(auto value, ReadValue<uint16_t>());
-    if (value > locals.size()) {
+    if (value > registers->buffer_views.size()) {
       return OutOfRangeErrorBuilder(IREE_LOC)
              << "Out of bounds local access " << value << " of "
-             << locals.size();
+             << registers->buffer_views.size();
     }
-    return &locals[value];
+    return &registers->buffer_views[value];
   }
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<hal::BufferView*> ReadLocal() {
-    return ReadLocal(locals_);
+    return ReadLocal(registers_);
   }
 
   Status SkipLocals(int count);
@@ -105,7 +106,7 @@
   template <typename T, size_t N = 8>
   ABSL_ATTRIBUTE_ALWAYS_INLINE StatusOr<absl::InlinedVector<T, N>>
   ReadSlotElements() {
-    ASSIGN_OR_RETURN(auto* local, ReadLocal(locals_));
+    ASSIGN_OR_RETURN(auto* local, ReadLocal(registers_));
     absl::InlinedVector<T, N> result(local->shape.element_count());
     if (sizeof(T) == local->element_size) {
       // Fast(ish) path: requested element size matches the actual element size.
@@ -154,13 +155,12 @@
     return value;
   }
 
-  Stack* stack_ = nullptr;
-  StackFrame* stack_frame_ = nullptr;
+  rt::Stack* stack_ = nullptr;
+  rt::StackFrame* stack_frame_ = nullptr;
   const uint8_t* bytecode_base_ = nullptr;
   const uint8_t* bytecode_limit_ = nullptr;
   const uint8_t* bytecode_pc_ = nullptr;
-  absl::Span<hal::BufferView> locals_;
-  FunctionTable::BreakpointTable* breakpoint_table_ = nullptr;
+  rt::Registers* registers_ = nullptr;
 };
 
 }  // namespace vm
diff --git a/iree/vm/bytecode_validator.cc b/iree/vm/bytecode_validator.cc
index c8a3bbd..968b193 100644
--- a/iree/vm/bytecode_validator.cc
+++ b/iree/vm/bytecode_validator.cc
@@ -18,7 +18,7 @@
 namespace vm {
 
 // static
-Status BytecodeValidator::Validate(const Context& context, const Module& module,
+Status BytecodeValidator::Validate(const BytecodeModule& module,
                                    const BytecodeDef& bytecode_def) {
   // TODO(benvanik): validate bytecode.
   return OkStatus();
diff --git a/iree/vm/bytecode_validator.h b/iree/vm/bytecode_validator.h
index bf435dc..429c754 100644
--- a/iree/vm/bytecode_validator.h
+++ b/iree/vm/bytecode_validator.h
@@ -17,8 +17,7 @@
 
 #include "iree/base/status.h"
 #include "iree/schemas/bytecode_def_generated.h"
-#include "iree/vm/context.h"
-#include "iree/vm/module.h"
+#include "iree/vm/bytecode_module.h"
 
 namespace iree {
 namespace vm {
@@ -28,7 +27,7 @@
 // be resolved with matching signatures.
 class BytecodeValidator {
  public:
-  static Status Validate(const Context& context, const Module& module,
+  static Status Validate(const BytecodeModule& module,
                          const BytecodeDef& bytecode_def);
 };
 
diff --git a/iree/vm/context.cc b/iree/vm/context.cc
deleted file mode 100644
index bae330a..0000000
--- a/iree/vm/context.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/context.h"
-
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-namespace {
-
-int NextUniqueId() {
-  static int next_id = 0;
-  return ++next_id;
-}
-
-}  // namespace
-
-Context::Context() : id_(NextUniqueId()) {}
-
-Context::~Context() = default;
-
-Status Context::RegisterNativeFunction(std::string name,
-                                       NativeFunction native_function) {
-  native_functions_.emplace_back(std::move(name), std::move(native_function));
-  return OkStatus();
-}
-
-Status Context::RegisterModule(std::unique_ptr<Module> module) {
-  // Attempt to link the module.
-  RETURN_IF_ERROR(module->mutable_function_table()->ResolveImports(
-      [&](const Module& importing_module,
-          const FunctionDef& import_function_def) -> StatusOr<ImportFunction> {
-        absl::string_view export_name = WrapString(import_function_def.name());
-
-        // Try to find a native function (we prefer these).
-        for (const auto& native_function : native_functions_) {
-          if (native_function.first == export_name) {
-            LOG(INFO) << "Resolved import '" << export_name
-                      << "' to native function";
-            return ImportFunction(importing_module, import_function_def,
-                                  native_function.second);
-          }
-        }
-
-        // Try to find an export in an existing module.
-        // We prefer the more recently registered modules.
-        // NOTE: slow O(n*m) search through all modules * exports.
-        for (auto it = modules_.rbegin(); it != modules_.rend(); ++it) {
-          const auto& module = *it;
-          auto export_or = module->function_table().LookupExport(export_name);
-          if (export_or.ok()) {
-            LOG(INFO) << "Resolved import '" << export_name << "' to module "
-                      << module->name();
-            return ImportFunction(importing_module, import_function_def,
-                                  export_or.ValueOrDie());
-          }
-        }
-
-        return NotFoundErrorBuilder(IREE_LOC)
-               << "Import '" << export_name << "' could not be resolved";
-      }));
-
-  modules_.push_back(std::move(module));
-  return OkStatus();
-}
-
-StatusOr<const Module*> Context::LookupModule(
-    absl::string_view module_name) const {
-  return const_cast<Context*>(this)->LookupModule(module_name);
-}
-
-StatusOr<Module*> Context::LookupModule(absl::string_view module_name) {
-  for (const auto& module : modules_) {
-    if (module->name() == module_name) {
-      return module.get();
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC)
-         << "No module with the name '" << module_name
-         << "' has been registered";
-}
-
-StatusOr<const Function> Context::LookupExport(
-    absl::string_view export_name) const {
-  for (const auto& module : modules_) {
-    auto export_or = module->function_table().LookupExport(export_name);
-    if (export_or.ok()) {
-      return export_or.ValueOrDie();
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC)
-         << "No export with the name '" << export_name
-         << "' is present in the context";
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/context.h b/iree/vm/context.h
deleted file mode 100644
index 6c3682b..0000000
--- a/iree/vm/context.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_CONTEXT_H_
-#define IREE_VM_CONTEXT_H_
-
-#include <memory>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/vm/function.h"
-#include "iree/vm/module.h"
-
-namespace iree {
-namespace vm {
-
-// An isolated execution context.
-// Effectively a sandbox where modules can be loaded and run with restricted
-// visibility. Each context may have its own set of imports that modules can
-// access and its own resource constraints.
-//
-// The function namespace is shared within a context, meaning that an import of
-// function 'a' from a module will resolve to an export of function 'a' from
-// another. Functions internal to a module are not resolved through the
-// namespace and may share names (or have no names at all).
-//
-// Modules have imports resolved automatically when loaded by searching existing
-// modules. This means that load order is important to ensure overrides are
-// respected. For example, target-specific modules should be loaded prior to
-// generic modules that may import functions defined there and if a function is
-// not available in the target-specific modules the fallback provided by the
-// generic module will be used.
-//
-// TODO(benvanik): evaluate if worth making thread-safe (epochs/generational).
-// Contexts are thread-compatible; const methods may be called concurrently from
-// any thread (including Invoke), however no threads must be using a shared
-// Context while new native functions or modules are registered.
-class Context {
- public:
-  Context();
-  Context(const Context&) = delete;
-  Context& operator=(const Context&) = delete;
-  Context(Context&&) = default;
-  Context& operator=(Context&&) = default;
-  virtual ~Context();
-
-  // A process-unique ID for the context.
-  int id() const { return id_; }
-
-  // TODO(benvanik): make immutable by moving to a static Create fn.
-  virtual Status RegisterNativeFunction(std::string name,
-                                        NativeFunction native_function);
-
-  virtual Status RegisterModule(std::unique_ptr<Module> module);
-
-  const std::vector<std::pair<std::string, NativeFunction>>& native_functions()
-      const {
-    return native_functions_;
-  }
-
-  const std::vector<std::unique_ptr<Module>>& modules() const {
-    return modules_;
-  }
-
-  StatusOr<const Module*> LookupModule(absl::string_view module_name) const;
-  StatusOr<Module*> LookupModule(absl::string_view module_name);
-  StatusOr<const Function> LookupExport(absl::string_view export_name) const;
-
- private:
-  int id_;
-  std::vector<std::pair<std::string, NativeFunction>> native_functions_;
-  std::vector<std::unique_ptr<Module>> modules_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_CONTEXT_H_
diff --git a/iree/vm/executable_table.cc b/iree/vm/executable_table.cc
deleted file mode 100644
index 0752fa3..0000000
--- a/iree/vm/executable_table.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/executable_table.h"
-
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-// static
-Status ExecutableTable::ValidateStructure(
-    const ExecutableTableDef& executable_table_def) {
-  if (!executable_table_def.multi_arch_executables()) {
-    // May have sequencer only fns. Fine to not have dispatchable executables.
-    return OkStatus();
-  }
-
-  // All fat executables need at least one device-specific executable.
-  const auto& multi_arch_executables =
-      *executable_table_def.multi_arch_executables();
-  for (int i = 0; i < multi_arch_executables.size(); ++i) {
-    const auto* multi_arch_executable = multi_arch_executables[i];
-    if (!multi_arch_executable || !multi_arch_executable->executables() ||
-        multi_arch_executable->executables()->size() == 0) {
-      return InvalidArgumentErrorBuilder(IREE_LOC)
-             << "Multi-arch executable ordinal " << i
-             << " is missing its contents";
-    }
-  }
-
-  return OkStatus();
-}
-
-ExecutableTable::ExecutableTable(const ExecutableTableDef& executable_table_def)
-    : executable_table_def_(executable_table_def) {}
-
-ExecutableTable::~ExecutableTable() = default;
-
-StatusOr<const MultiArchExecutableDef*>
-ExecutableTable::LookupMultiArchExecutable(int executable_ordinal) const {
-  if (executable_ordinal < 0 ||
-      executable_ordinal >=
-          executable_table_def_.multi_arch_executables()->size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Invalid multi-arch executable ordinal " << executable_ordinal;
-  }
-  return executable_table_def_.multi_arch_executables()->Get(
-      executable_ordinal);
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/executable_table.h b/iree/vm/executable_table.h
deleted file mode 100644
index e26918d..0000000
--- a/iree/vm/executable_table.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_EXECUTABLE_TABLE_H_
-#define IREE_VM_EXECUTABLE_TABLE_H_
-
-#include "iree/base/status.h"
-#include "iree/schemas/executable_table_def_generated.h"
-
-namespace iree {
-namespace vm {
-
-// A table of executables present within a module.
-// Manages lookup and selection of executables based on target devices.
-//
-// Thread-safe.
-class ExecutableTable {
- public:
-  static Status ValidateStructure(
-      const ExecutableTableDef& executable_table_def);
-
-  explicit ExecutableTable(const ExecutableTableDef& executable_table_def);
-  ExecutableTable(const ExecutableTable&) = delete;
-  ExecutableTable& operator=(const ExecutableTable&) = delete;
-  ~ExecutableTable();
-
-  const ExecutableTableDef& def() const { return executable_table_def_; }
-
-  StatusOr<const MultiArchExecutableDef*> LookupMultiArchExecutable(
-      int executable_ordinal) const;
-
-  // TODO(benvanik): resolve executable by ID+format+features (ExecutableDef).
-
-  // TODO(benvanik): insert/get HAL executables (thread-safe!).
-
- private:
-  const ExecutableTableDef& executable_table_def_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_EXECUTABLE_TABLE_H_
diff --git a/iree/vm/fiber_state.cc b/iree/vm/fiber_state.cc
deleted file mode 100644
index 90d9fd4..0000000
--- a/iree/vm/fiber_state.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/fiber_state.h"
-
-#include <iterator>
-
-#include "absl/strings/str_join.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-FiberState::FiberState(std::shared_ptr<Instance> instance)
-    : instance_(std::move(instance)), id_(Instance::NextUniqueId()) {
-}
-
-FiberState::~FiberState() {
-}
-
-bool FiberState::is_suspended() {
-  // TODO(benvanik): implement.
-  return false;
-}
-
-Status FiberState::Suspend(SuspendCallback suspend_callback) {
-  DVLOG(1) << "Suspending fiber " << id();
-  return OkStatus();
-}
-
-Status FiberState::Resume() {
-  DVLOG(1) << "Resuming fiber " << id();
-  return OkStatus();
-}
-
-Status FiberState::Step(StepTarget step_target,
-                        SuspendCallback suspend_callback) {
-  return UnimplementedErrorBuilder(IREE_LOC) << "Step not yet implemented";
-}
-
-namespace {
-struct StackFrameFormatter {
-  void operator()(std::string* out, const StackFrame& stack_frame) const {
-    out->append(absl::StrCat(stack_frame.module().name(), ":",
-                             stack_frame.function().name(), "@",
-                             stack_frame.offset()));
-  }
-};
-}  // namespace
-
-std::string FiberState::DebugString() const {
-  auto frames = stack_.frames();
-  return absl::StrJoin(frames.begin(), frames.end(), "\n",
-                       StackFrameFormatter());
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/fiber_state.h b/iree/vm/fiber_state.h
deleted file mode 100644
index 5799831..0000000
--- a/iree/vm/fiber_state.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_FIBER_STATE_H_
-#define IREE_VM_FIBER_STATE_H_
-
-#include <functional>
-
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/stack.h"
-
-namespace iree {
-namespace vm {
-
-// Fiber call stack and state machine model.
-// Fibers may not line up with host application threads and execution may move
-// across threads.
-//
-// Fibers are thread-compatible. Certain methods, such as Suspend and Resume
-// (and others that explicitly call them) may be called from other threads,
-// however members and other methods should be assumed safe to use only from
-// the owning thread or when is_suspended returns true.
-class FiberState {
- public:
-  // Called when a fiber completes suspending (in response to a Suspend or Step
-  // request). The |suspend_status| will indicate if the suspension was
-  // successful.
-  using SuspendCallback = std::function<void(Status suspend_status)>;
-
-  struct StepTarget {
-    // TODO(benvanik): step target info (matching RPC message).
-    // module / function / offset
-    // relative to current: once, out, return, etc
-  };
-
-  explicit FiberState(std::shared_ptr<Instance> instance);
-  FiberState(const FiberState&) = delete;
-  FiberState& operator=(const FiberState&) = delete;
-  ~FiberState();
-
-  // A process-unique ID for the fiber.
-  int id() const { return id_; }
-
-  const std::shared_ptr<Instance>& instance() const { return instance_; }
-
-  // VM call stack.
-  // NOTE: only valid while suspended.
-  const Stack& stack() const { return stack_; }
-  Stack* mutable_stack() { return &stack_; }
-
-  // Returns true if the fiber is suspended.
-  // This only returns true if the fiber has been requested to suspend with
-  // Suspend and the runtime has acked the suspend. Once suspended (and until
-  // resumed) fiber state will not change and may be observed from any thread.
-  //
-  // Safe to call from any thread.
-  bool is_suspended();
-
-  // Suspends the fiber at the next possible chance.
-  //
-  // Fibers have a suspension depth and each call to Suspend must be matched
-  // with a call to Resume. Fibers will only resume excution when all prior
-  // Suspend calls have their matching Resume called.
-  //
-  // Optionally callers may provide a |suspend_callback| that will be called
-  // from a random thread when the fiber is suspended (or fails to suspend).
-  //
-  // Safe to call from any thread.
-  Status Suspend(SuspendCallback suspend_callback = nullptr);
-
-  // Resumes the fiber if it is suspended (or cancels a pending suspend).
-  // This may wake threads if they are currently waiting on the fiber to
-  // execute.
-  //
-  // Safe to call from any thread.
-  Status Resume();
-
-  // Steps fiber execution.
-  // This will attempt to resume the fiber and will complete asynchronously.
-  // Upon returning the fiber should be assumed resumed and callers must query
-  // is_suspended to wait until the fiber suspends again. Optionally callers may
-  // provide a |suspend_callback| that will be called from a random thread when
-  // the fiber is suspended (or fails to suspend).
-  //
-  // Safe to call from any thread while the fiber is suspended.
-  Status Step(StepTarget step_target,
-              SuspendCallback suspend_callback = nullptr);
-
-  std::string DebugString() const;
-
- private:
-  std::shared_ptr<Instance> instance_;
-  int id_;
-  Stack stack_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_FIBER_STATE_H_
diff --git a/iree/vm/function.cc b/iree/vm/function.cc
deleted file mode 100644
index 1e92c28..0000000
--- a/iree/vm/function.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/function.h"
-
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "iree/base/flatbuffer_util.h"
-#include "iree/schemas/type_def_generated.h"
-
-namespace iree {
-namespace vm {
-
-namespace {
-
-struct TypeFormatter {
-  void operator()(std::string* out, const TypeDef* type_def) const {
-    switch (type_def->type_union_type()) {
-      case TypeDefUnion::MemRefTypeDef:
-        (*this)(out, type_def->type_union_as_MemRefTypeDef());
-        return;
-      case TypeDefUnion::DeviceTypeDef:
-        out->append("device");
-        return;
-      case TypeDefUnion::CommandBufferTypeDef:
-        out->append("command_buffer");
-        return;
-      case TypeDefUnion::EventTypeDef:
-        out->append("event");
-        return;
-      case TypeDefUnion::SemaphoreTypeDef:
-        out->append("semaphore");
-        return;
-      case TypeDefUnion::FenceTypeDef:
-        out->append("fence");
-        return;
-      default:
-        out->append("<invalid>");
-        return;
-    }
-  }
-
-  void operator()(std::string* out,
-                  const MemRefTypeDef* mem_ref_type_def) const {
-    out->append("memref<");
-    if (mem_ref_type_def->shape()) {
-      for (int dim : *mem_ref_type_def->shape()) {
-        out->append(std::to_string(dim));
-        out->append("x");
-      }
-    } else {
-      out->append("?x");
-    }
-    (*this)(out, mem_ref_type_def->element_type());
-    out->append(">");
-  }
-
-  void operator()(std::string* out, const ElementTypeDef* type_def) const {
-    switch (type_def->type_union_type()) {
-      case ElementTypeDefUnion::FloatTypeDef: {
-        const auto* float_type_def = type_def->type_union_as_FloatTypeDef();
-        out->append("f");
-        out->append(std::to_string(float_type_def->width()));
-        break;
-      }
-      case ElementTypeDefUnion::IntegerTypeDef: {
-        const auto* int_type_def = type_def->type_union_as_IntegerTypeDef();
-        out->append("i");
-        out->append(std::to_string(int_type_def->width()));
-        break;
-      }
-      case ElementTypeDefUnion::UnknownTypeDef: {
-        const auto* unknown_type_def = type_def->type_union_as_UnknownTypeDef();
-        out->append("unknown<");
-        auto dialect_str = WrapString(unknown_type_def->dialect());
-        out->append(dialect_str.data(), dialect_str.size());
-        auto type_data_str = WrapString(unknown_type_def->type_data());
-        out->append(type_data_str.data(), type_data_str.size());
-        out->append(">");
-        break;
-      }
-      default:
-        out->append("<invalid>");
-        return;
-    }
-  }
-};
-
-}  // namespace
-
-std::string Function::DebugStringShort() const {
-  return absl::StrCat(
-      name(), "(",
-      type_def().inputs()
-          ? absl::StrJoin(*type_def().inputs(), ", ", TypeFormatter())
-          : "",
-      ") -> (",
-      type_def().results()
-          ? absl::StrJoin(*type_def().results(), ", ", TypeFormatter())
-          : "",
-      ")");
-}
-
-std::string ImportFunction::DebugStringShort() const {
-  // TODO(benvanik): import function strings.
-  return "(IMPORT)";
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/function.h b/iree/vm/function.h
deleted file mode 100644
index 7f590a0..0000000
--- a/iree/vm/function.h
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_FUNCTION_H_
-#define IREE_VM_FUNCTION_H_
-
-#include <functional>
-
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-#include "iree/hal/buffer_view.h"
-#include "iree/schemas/function_def_generated.h"
-#include "iree/schemas/type_def_generated.h"
-
-namespace iree {
-namespace vm {
-
-class Stack;
-class Module;
-
-// TODO(benvanik): reorganize this; I don't like it. maybe ImportFunction
-// shouldn't derive from Function at all?
-
-// A function defined within a Module.
-// Imported functions may be of the ImportFunction type and contain additional
-// runtime linkage information.
-class Function {
- public:
-  Function() = default;
-  Function(const Module& module, const FunctionDef& function_def)
-      : module_(&module), function_def_(&function_def) {}
-
-  absl::string_view name() const { return WrapString(function_def_->name()); }
-
-  const Module& module() const { return *module_; }
-  const FunctionDef& def() const { return *function_def_; }
-  const FunctionTypeDef& type_def() const { return *def().type(); }
-
-  int input_count() const {
-    return type_def().inputs() ? type_def().inputs()->size() : 0;
-  }
-  int result_count() const {
-    return type_def().results() ? type_def().results()->size() : 0;
-  }
-
-  std::string DebugStringShort() const;
-
- private:
-  const Module* module_ = nullptr;
-  const FunctionDef* function_def_ = nullptr;
-};
-
-inline std::ostream& operator<<(std::ostream& stream,
-                                const Function& function) {
-  stream << function.DebugStringShort();
-  return stream;
-}
-
-// TODO(benvanik): make an interface as well.
-// TODO(benvanik): pass through additional attributes.
-using NativeFunction =
-    std::function<Status(Stack* stack, absl::Span<hal::BufferView> args,
-                         absl::Span<hal::BufferView> results)>;
-
-// A function imported into a Module from either a native function or other
-// module.
-class ImportFunction : public Function {
- public:
-  enum class LinkType {
-    kNativeFunction,
-    kModule,
-  };
-
-  ImportFunction() = default;
-  ImportFunction(const Module& module, const FunctionDef& function_def,
-                 NativeFunction native_function)
-      : Function(module, function_def),
-        link_type_(LinkType::kNativeFunction),
-        native_function_(std::move(native_function)) {}
-  ImportFunction(const Module& module, const FunctionDef& function_def,
-                 Function linked_function)
-      : Function(module, function_def),
-        link_type_(LinkType::kModule),
-        linked_function_(std::move(linked_function)) {}
-  ImportFunction(const ImportFunction&) = delete;
-  ImportFunction& operator=(const ImportFunction&) = delete;
-  ImportFunction(ImportFunction&&) = default;
-  ImportFunction& operator=(ImportFunction&&) = default;
-
-  LinkType link_type() const { return link_type_; }
-  const NativeFunction& native_function() const { return native_function_; }
-  const Function& linked_function() const { return linked_function_; }
-
-  std::string DebugStringShort() const;
-
- private:
-  LinkType link_type_;
-  NativeFunction native_function_;
-  Function linked_function_;
-};
-
-inline std::ostream& operator<<(std::ostream& stream,
-                                const ImportFunction& function) {
-  stream << function.DebugStringShort();
-  return stream;
-}
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_FUNCTION_H_
diff --git a/iree/vm/function_table.cc b/iree/vm/function_table.cc
deleted file mode 100644
index 1e629bd..0000000
--- a/iree/vm/function_table.cc
+++ /dev/null
@@ -1,261 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/function_table.h"
-
-#include "absl/container/flat_hash_map.h"
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-namespace {
-
-Status ValidateType(const FunctionTypeDef& type_def) {
-  // Ensure all fields are populated.
-  return OkStatus();
-}
-
-}  // namespace
-
-// static
-Status FunctionTable::ValidateStructure(
-    const FunctionTableDef& function_table_def) {
-  if (!function_table_def.functions()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function table is missing the function listing";
-  }
-
-  // All functions must contain a valid type.
-  const auto& functions = *function_table_def.functions();
-  for (int i = 0; i < functions.size(); ++i) {
-    const auto* function = functions[i];
-    if (!function) {
-      return InvalidArgumentErrorBuilder(IREE_LOC)
-             << "Function ordinal " << i << " is missing its contents";
-    }
-    if (!function->type()) {
-      return InvalidArgumentErrorBuilder(IREE_LOC)
-             << "Function ordinal " << i << " is missing its type";
-    }
-    RETURN_IF_ERROR(ValidateType(*function->type()));
-  }
-
-  // Imports must also have a name (that we can use to resolve it).
-  if (function_table_def.imports()) {
-    const auto& imports = *function_table_def.imports();
-    for (int i = 0; i < imports.size(); ++i) {
-      int function_index = imports[i];
-      if (!functions[function_index]->name()) {
-        return InvalidArgumentErrorBuilder(IREE_LOC)
-               << "Import ordinal " << i << " is missing its contents";
-      }
-    }
-  }
-
-  // Exports must also have a name (that others will use to look it up).
-  if (function_table_def.exports()) {
-    const auto& exports = *function_table_def.exports();
-    for (int i = 0; i < exports.size(); ++i) {
-      int function_index = exports[i];
-      if (!functions[function_index]->name()) {
-        return InvalidArgumentErrorBuilder(IREE_LOC)
-               << "Export ordinal " << i << " is missing its contents";
-      }
-    }
-  }
-
-  return OkStatus();
-}
-
-FunctionTable::FunctionTable(const Module& module,
-                             const FunctionTableDef& function_table_def)
-    : module_(module), function_table_def_(function_table_def) {}
-
-FunctionTable::~FunctionTable() = default;
-
-Status FunctionTable::ResolveImports(ImportResolver import_resolver) {
-  if (!function_table_def_.imports()) {
-    // No imports to resolve.
-    return OkStatus();
-  }
-
-  const auto& imports = *function_table_def_.imports();
-  const auto& functions = *function_table_def_.functions();
-  for (int i = 0; i < imports.size(); ++i) {
-    const auto* function_def = functions[imports[i]];
-    ASSIGN_OR_RETURN(auto import_function,
-                     import_resolver(module_, *function_def));
-    import_functions_.push_back(std::move(import_function));
-  }
-
-  return OkStatus();
-}
-
-StatusOr<int> FunctionTable::LookupImportOrdinal(
-    absl::string_view import_name) const {
-  if (function_table_def_.imports()) {
-    const auto& imports = *function_table_def_.imports();
-    const auto& functions = *function_table_def_.functions();
-    for (int i = 0; i < imports.size(); ++i) {
-      if (WrapString(functions[imports[i]]->name()) == import_name) {
-        return i;
-      }
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC)
-         << "Import with the name '" << import_name << "' not found in module";
-}
-
-StatusOr<const ImportFunction*> FunctionTable::LookupImport(
-    absl::string_view import_name) const {
-  ASSIGN_OR_RETURN(int import_ordinal, LookupImportOrdinal(import_name));
-  return LookupImport(import_ordinal);
-}
-
-StatusOr<const ImportFunction*> FunctionTable::LookupImport(
-    int import_ordinal) const {
-  if (import_ordinal < 0 || import_ordinal >= import_functions_.size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Import ordinal " << import_ordinal
-           << " is outside the valid range [0, " << import_functions_.size()
-           << ")";
-  }
-  return {&import_functions_[import_ordinal]};
-}
-
-StatusOr<int> FunctionTable::LookupExportFunctionOrdinal(
-    absl::string_view export_name) const {
-  // NOTE: this is a linear scan of the export table, but since export count
-  // is usually small and the only time this lookup should happen is on module
-  // load it's (probably) fine.
-  if (function_table_def_.exports()) {
-    const auto& exports = *function_table_def_.exports();
-    for (int i = 0; i < exports.size(); ++i) {
-      int export_ordinal = exports.Get(i);
-      const auto& function_def =
-          *function_table_def_.functions()->Get(export_ordinal);
-      if (WrapString(function_def.name()) == export_name) {
-        return export_ordinal;
-      }
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC)
-         << "Export with the name '" << export_name << "' not found in module";
-}
-
-StatusOr<const Function> FunctionTable::LookupExport(
-    absl::string_view export_name) const {
-  ASSIGN_OR_RETURN(int export_ordinal,
-                   LookupExportFunctionOrdinal(export_name));
-  return LookupFunction(export_ordinal);
-}
-
-StatusOr<const Function> FunctionTable::LookupExport(int export_ordinal) const {
-  if (!function_table_def_.exports() || export_ordinal < 0 ||
-      export_ordinal >= function_table_def_.exports()->size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Export ordinal " << export_ordinal
-           << " is outside the valid range [0, "
-           << function_table_def_.exports()->size() << ")";
-  }
-  const auto& exports = *function_table_def_.exports();
-  int function_ordinal = exports.Get(export_ordinal);
-  return LookupFunction(function_ordinal);
-}
-
-StatusOr<const Function> FunctionTable::LookupFunction(int ordinal) const {
-  if (ordinal < 0 || ordinal >= function_table_def_.functions()->size()) {
-    return OutOfRangeErrorBuilder(IREE_LOC)
-           << "Function ordinal " << ordinal
-           << " is outside the valid range [0, "
-           << function_table_def_.functions()->size() << ")";
-  }
-  const auto* function_def = function_table_def_.functions()->Get(ordinal);
-  return Function(module_, *function_def);
-}
-
-StatusOr<int> FunctionTable::LookupFunctionOrdinal(
-    const Function& function) const {
-  const auto& functions = *function_table_def_.functions();
-  for (int i = 0; i < functions.size(); ++i) {
-    if (&function.def() == functions.Get(i)) {
-      return i;
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC) << "Function not a member of module";
-}
-
-StatusOr<int> FunctionTable::LookupFunctionOrdinalByName(
-    absl::string_view name) const {
-  for (int i = 0; i < function_table_def_.functions()->size(); ++i) {
-    const auto* function_def = function_table_def_.functions()->Get(i);
-    if (WrapString(function_def->name()) == name) {
-      return i;
-    }
-  }
-  return NotFoundErrorBuilder(IREE_LOC)
-         << "Function '" << name
-         << "' not found in function table (or names have been stripped)";
-}
-
-Status FunctionTable::RegisterBreakpoint(int function_ordinal, int offset,
-                                         BreakpointCallback callback) {
-  if (breakpoint_tables_.empty()) {
-    breakpoint_tables_.resize(function_table_def_.functions()->size());
-  }
-  if (function_ordinal < 0 || function_ordinal > breakpoint_tables_.size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function ordinal " << function_ordinal << " out of bounds";
-  }
-  if (!breakpoint_tables_[function_ordinal]) {
-    breakpoint_tables_[function_ordinal] =
-        absl::make_unique<absl::flat_hash_map<int, BreakpointCallback>>();
-  }
-  auto& function_table = *breakpoint_tables_[function_ordinal];
-  function_table[offset] = std::move(callback);
-  return OkStatus();
-}
-
-Status FunctionTable::UnregisterBreakpoint(int function_ordinal, int offset) {
-  if (function_ordinal < 0 || function_ordinal > breakpoint_tables_.size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function ordinal " << function_ordinal << " out of bounds";
-  }
-  auto* function_table = breakpoint_tables_[function_ordinal].get();
-  if (function_table) {
-    auto it = function_table->find(offset);
-    if (it != function_table->end()) {
-      function_table->erase(it);
-    }
-  }
-  return OkStatus();
-}
-
-Status FunctionTable::UnregisterAllBreakpoints() {
-  breakpoint_tables_.clear();
-  return OkStatus();
-}
-
-FunctionTable::BreakpointTable* FunctionTable::GetFunctionBreakpointTable(
-    int function_ordinal) const {
-  if (function_ordinal < 0 || function_ordinal >= breakpoint_tables_.size()) {
-    return nullptr;
-  }
-  return breakpoint_tables_[function_ordinal].get();
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/function_table.h b/iree/vm/function_table.h
deleted file mode 100644
index e7a1034..0000000
--- a/iree/vm/function_table.h
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_FUNCTION_TABLE_H_
-#define IREE_VM_FUNCTION_TABLE_H_
-
-#include <functional>
-#include <vector>
-
-#include "absl/container/flat_hash_map.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/schemas/function_table_def_generated.h"
-#include "iree/vm/function.h"
-
-namespace iree {
-namespace vm {
-
-class Stack;
-class Module;
-
-// A table of functions present within a module.
-// Manages the import table, local function resolution, and breakpoints.
-//
-// Function tables are normally thread-compatible. Debugging-specific methods
-// like RegisterBreakpoint must only be called when the debugger has suspended
-// all fibers that could be executing functions from the table.
-class FunctionTable {
- public:
-  static Status ValidateStructure(const FunctionTableDef& function_table_def);
-
-  FunctionTable(const Module& module,
-                const FunctionTableDef& function_table_def);
-  FunctionTable(const FunctionTable&) = delete;
-  FunctionTable& operator=(const FunctionTable&) = delete;
-  ~FunctionTable();
-
-  const FunctionTableDef& def() const { return function_table_def_; }
-
-  using ImportResolver = std::function<StatusOr<ImportFunction>(
-      const Module& importing_module, const FunctionDef& import_function_def)>;
-  Status ResolveImports(ImportResolver import_resolver);
-
-  StatusOr<const ImportFunction*> LookupImport(
-      absl::string_view import_name) const;
-  StatusOr<const ImportFunction*> LookupImport(int import_ordinal) const;
-
-  StatusOr<const Function> LookupExport(absl::string_view export_name) const;
-  StatusOr<const Function> LookupExport(int export_ordinal) const;
-
-  StatusOr<const Function> LookupFunction(int ordinal) const;
-
-  StatusOr<int> LookupFunctionOrdinal(const Function& function) const;
-  StatusOr<int> LookupFunctionOrdinalByName(absl::string_view name) const;
-
-  // Handles breakpoints that are encountered during execution.
-  // The current function and offset within the function will be provided.
-  // The fiber is set as suspended prior to issuing the callback and resumed
-  // if the callback returns ok.
-  //
-  // Implementations can use the return status to indicate intended program
-  // flow:
-  //  - return ok to resume the fiber and continue execution
-  //  - return abort to terminate the fiber
-  //  - return an error to propagate via normal error handling logic
-  using BreakpointCallback = std::function<Status(const Stack& stack)>;
-
-  // Registers a breakpoint for an operation offset within a function.
-  // The provided callback will be issued when the breakpoint is hit. If a
-  // breakpoint already exists for the given offset it will be replaced.
-  //
-  // The global debug lock must be held and all fibers must be suspended.
-  Status RegisterBreakpoint(int function_ordinal, int offset,
-                            BreakpointCallback callback);
-
-  // Unregisters a breakpoint, if one has been registered.
-  //
-  // The global debug lock must be held and all fibers must be suspended.
-  Status UnregisterBreakpoint(int function_ordinal, int offset);
-
-  // Unregisters all breakpoints in the function table.
-  //
-  // The global debug lock must be held and all fibers must be suspended.
-  Status UnregisterAllBreakpoints();
-
-  using BreakpointTable = absl::flat_hash_map<int, BreakpointCallback>;
-
-  // Returns the breakpoint table mapping offset to breakpoint callback.
-  // Returns nullptr if the given function does not have a breakpoint table.
-  //
-  // This table is not synchronized and while the debug lock is held it must not
-  // be accessed by any other threads. Reading is otherwise safe.
-  BreakpointTable* GetFunctionBreakpointTable(int function_ordinal) const;
-
- private:
-  StatusOr<int> LookupImportOrdinal(absl::string_view import_name) const;
-  StatusOr<int> LookupExportFunctionOrdinal(
-      absl::string_view export_name) const;
-
-  const Module& module_;
-  const FunctionTableDef& function_table_def_;
-  std::vector<ImportFunction> import_functions_;
-
-  // One slot per function in the function table. The hash map contains the
-  // breakpoints for that particular function mapped by offset within the
-  // function.
-  std::vector<std::unique_ptr<BreakpointTable>> breakpoint_tables_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_FUNCTION_TABLE_H_
diff --git a/iree/vm/instance.cc b/iree/vm/instance.cc
deleted file mode 100644
index 7668d73..0000000
--- a/iree/vm/instance.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/instance.h"
-
-#include "absl/memory/memory.h"
-#include "iree/base/source_location.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-// static
-int Instance::NextUniqueId() {
-  static int next_id = 0;
-  return ++next_id;
-}
-
-Instance::Instance()
-    : device_manager_(absl::make_unique<hal::DeviceManager>()) {}
-
-Instance::~Instance() = default;
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/instance.h b/iree/vm/instance.h
deleted file mode 100644
index 68c4524..0000000
--- a/iree/vm/instance.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_INSTANCE_H_
-#define IREE_VM_INSTANCE_H_
-
-#include <memory>
-
-#include "iree/hal/device_manager.h"
-
-namespace iree {
-namespace vm {
-
-// Shared runtime instance responsible for routing Context events, enumerating
-// and creating hardware device interfaces, and managing thread pools.
-//
-// A single runtime instance can service multiple contexts and hosting
-// applications should try to reuse a runtime as much as possible. This ensures
-// that resource allocation across contexts is handled and extraneous device
-// interaction is avoided.
-class Instance {
- public:
-  // Allocates a global unique ID.
-  static int NextUniqueId();
-
-  Instance();
-  ~Instance();
-  Instance(const Instance&) = delete;
-  Instance& operator=(const Instance&) = delete;
-
-  hal::DeviceManager* device_manager() const { return device_manager_.get(); }
-
- private:
-  std::unique_ptr<hal::DeviceManager> device_manager_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_INSTANCE_H_
diff --git a/iree/vm/module.cc b/iree/vm/module.cc
deleted file mode 100644
index 4aaa634..0000000
--- a/iree/vm/module.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/module.h"
-
-#include "absl/memory/memory.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-// static
-Status Module::ValidateStructure(const ModuleDef& module_def) {
-  // Must have a function table.
-  if (module_def.function_table()) {
-    RETURN_IF_ERROR(
-        FunctionTable::ValidateStructure(*module_def.function_table()));
-  } else {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "ModuleDef is missing a function table";
-  }
-
-  // May optionally have an executable table.
-  if (module_def.executable_table()) {
-    RETURN_IF_ERROR(
-        ExecutableTable::ValidateStructure(*module_def.executable_table()));
-  }
-
-  return OkStatus();
-}
-
-// static
-StatusOr<std::unique_ptr<Module>> Module::FromDef(const ModuleDef& module_def) {
-  ASSIGN_OR_RETURN(auto module_file, ModuleFile::Create(&module_def, []() {}));
-  return FromFile(std::move(module_file));
-}
-
-// static
-StatusOr<std::unique_ptr<Module>> Module::FromFile(
-    std::unique_ptr<ModuleFile> module_file) {
-  if (module_file->root() == nullptr) {
-    return InvalidArgumentErrorBuilder(IREE_LOC) << "No root ModuleDef present";
-  }
-  const auto& module_def = *module_file->root();
-
-  // Validates the structure of the module (but not bytecode).
-  // This ensures we don't have flatbuffer vectors will null entries, etc.
-  RETURN_IF_ERROR(Module::ValidateStructure(module_def));
-
-  auto module = absl::WrapUnique(new Module(std::move(module_file)));
-
-  // TODO(benvanik): validate internals here? or make explicit?
-
-  return {std::move(module)};
-}
-
-Module::Module(std::unique_ptr<ModuleFile> module_file)
-    : module_file_(std::move(module_file)),
-      module_def_(*module_file_->root()),
-      function_table_(*this, *module_def_.function_table()),
-      executable_table_(*module_def_.executable_table()) {}
-
-Module::~Module() = default;
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/module.h b/iree/vm/module.h
deleted file mode 100644
index 01cfc0d..0000000
--- a/iree/vm/module.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_MODULE_H_
-#define IREE_VM_MODULE_H_
-
-#include <memory>
-
-#include "iree/base/flatbuffer_util.h"
-#include "iree/schemas/module_def_generated.h"
-#include "iree/vm/executable_table.h"
-#include "iree/vm/function_table.h"
-
-namespace iree {
-namespace vm {
-
-using ModuleFile = FlatBufferFile<ModuleDef>;
-
-// A loaded bytecode module.
-class Module {
- public:
-  static Status ValidateStructure(const ModuleDef& module_def);
-
-  static StatusOr<std::unique_ptr<Module>> FromDef(const ModuleDef& module_def);
-  static StatusOr<std::unique_ptr<Module>> FromFile(
-      std::unique_ptr<ModuleFile> module_file);
-
-  Module(const Module&) = delete;
-  Module& operator=(const Module&) = delete;
-  ~Module();
-
-  absl::string_view name() const { return WrapString(module_def_.name()); }
-
-  const ModuleDef& def() const { return module_def_; }
-  const FunctionTable& function_table() const { return function_table_; }
-  FunctionTable* mutable_function_table() { return &function_table_; }
-  const ExecutableTable& executable_table() const { return executable_table_; }
-  ExecutableTable* mutable_executable_table() { return &executable_table_; }
-
- private:
-  explicit Module(std::unique_ptr<ModuleFile> module_file);
-
-  std::unique_ptr<ModuleFile> module_file_;
-  const ModuleDef& module_def_;
-  FunctionTable function_table_;
-  ExecutableTable executable_table_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_MODULE_H_
diff --git a/iree/vm/module_printer.cc b/iree/vm/module_printer.cc
deleted file mode 100644
index 2304d33..0000000
--- a/iree/vm/module_printer.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/module_printer.h"
-
-#include "iree/vm/bytecode_printer.h"
-#include "iree/vm/source_map.h"
-
-namespace iree {
-namespace vm {
-
-Status PrintModuleToStream(OpcodeTable opcode_table, const Module& module,
-                           PrintModuleFlagBitfield flags,
-                           std::ostream* stream) {
-  // TODO(benvanik): custom FunctionTable Function iterator.
-  for (int i = 0; i < module.function_table().def().functions()->size(); ++i) {
-    ASSIGN_OR_RETURN(const auto& function,
-                     module.function_table().LookupFunction(i));
-    if (function.def().bytecode()) {
-      auto source_map_resolver =
-          AllBitsSet(flags, PrintModuleFlag::kIncludeSourceMapping)
-              ? SourceMapResolver::FromFunction(module.def(), i)
-              : SourceMapResolver();
-      BytecodePrinter printer(opcode_table, module.function_table(),
-                              module.executable_table(), source_map_resolver);
-      *stream << "Function " << i << ": " << function << "\n";
-      RETURN_IF_ERROR(
-          printer.PrintToStream(*function.def().bytecode(), stream));
-      *stream << "\n";
-    } else {
-      *stream << "Function " << i << ": " << function.name() << " (import)\n";
-    }
-  }
-  return OkStatus();
-}
-
-Status PrintModuleToStream(OpcodeTable opcode_table, const Module& module,
-                           std::ostream* stream) {
-  return PrintModuleToStream(opcode_table, module, PrintModuleFlag::kNone,
-                             stream);
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/sequencer_context.cc b/iree/vm/sequencer_context.cc
deleted file mode 100644
index a8bda41..0000000
--- a/iree/vm/sequencer_context.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/sequencer_context.h"
-
-#include "iree/base/flatbuffer_util.h"
-#include "iree/base/status.h"
-#include "iree/hal/buffer_view.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/sequencer_dispatch.h"
-
-namespace iree {
-namespace vm {
-
-namespace {
-
-using ::iree::hal::BufferView;
-
-Status ValidateElementSize(int element_bit_width,
-                           const ElementTypeDef& expected_element_type) {
-  switch (expected_element_type.type_union_type()) {
-    case ElementTypeDefUnion::FloatTypeDef: {
-      auto expected_bit_width =
-          expected_element_type.type_union_as_FloatTypeDef()->width();
-      if (element_bit_width != expected_bit_width) {
-        return InvalidArgumentErrorBuilder(IREE_LOC)
-               << "Has element bit width " << element_bit_width
-               << " but expected " << expected_bit_width;
-      }
-      return OkStatus();
-    }
-    case ElementTypeDefUnion::IntegerTypeDef: {
-      auto expected_bit_width =
-          expected_element_type.type_union_as_IntegerTypeDef()->width();
-      if (element_bit_width != expected_bit_width) {
-        return InvalidArgumentErrorBuilder(IREE_LOC)
-               << "Has element bit width " << element_bit_width
-               << " but expected " << expected_bit_width;
-      }
-      return OkStatus();
-    }
-    case ElementTypeDefUnion::UnknownTypeDef:
-    case ElementTypeDefUnion::NONE: {
-    }
-  }
-  return InvalidArgumentErrorBuilder(IREE_LOC)
-         << "Defined type has unsupported element type "
-         << EnumNameElementTypeDefUnion(
-                expected_element_type.type_union_type());
-}
-
-Status ValidateArgType(const BufferView& arg,
-                       const MemRefTypeDef& expected_type) {
-  RETURN_IF_ERROR(
-      ValidateElementSize(arg.element_size * 8, *expected_type.element_type()));
-
-  auto expected_shape = expected_type.shape();
-  if (arg.shape.size() != expected_shape->size()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Argument should have rank " << expected_shape->size()
-           << " but has rank " << arg.shape.size();
-  }
-  for (int i = 0; i < expected_shape->size(); ++i) {
-    auto dim_size = arg.shape[i];
-    auto expected_dim_size = expected_shape->Get(i);
-    if (dim_size != expected_dim_size) {
-      return InvalidArgumentErrorBuilder(IREE_LOC)
-             << "Argument dimension " << i << " should have size "
-             << expected_dim_size << " but has size " << dim_size;
-    }
-  }
-  return OkStatus();
-}
-
-}  // namespace
-
-SequencerContext::SequencerContext(std::shared_ptr<Instance> instance)
-    : instance_(std::move(instance)) {}
-
-SequencerContext::~SequencerContext() = default;
-
-Status SequencerContext::RegisterNativeFunction(
-    std::string name, NativeFunction native_function) {
-  // TODO(benvanik): provide to debugger.
-  return Context::RegisterNativeFunction(std::move(name),
-                                         std::move(native_function));
-}
-
-Status SequencerContext::RegisterModule(std::unique_ptr<Module> module) {
-  RETURN_IF_ERROR(Context::RegisterModule(std::move(module)));
-  return OkStatus();
-}
-
-Status SequencerContext::Invoke(FiberState* fiber_state, Function function,
-                                absl::Span<BufferView> args,
-                                absl::Span<BufferView> results) const {
-  // Verify arg/result counts.
-  if (args.size() != function.input_count()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function " << function.name() << " requires "
-           << function.input_count() << " inputs but " << args.size()
-           << " provided";
-  }
-  if (results.size() != function.result_count()) {
-    return InvalidArgumentErrorBuilder(IREE_LOC)
-           << "Function " << function.name() << " requires "
-           << function.result_count() << " outputs but " << results.size()
-           << " provided";
-  }
-
-  // Push stack frame for the function we are calling.
-  auto* stack = fiber_state->mutable_stack();
-  ASSIGN_OR_RETURN(auto* callee_stack_frame, stack->PushFrame(function));
-
-  // Marshal input arguments.
-  for (int i = 0; i < args.size(); ++i) {
-    auto arg = args[i];
-    auto expected_arg_type = function.type_def().inputs()->Get(i);
-    RETURN_IF_ERROR(
-        ValidateArgType(arg, *expected_arg_type->type_union_as_MemRefTypeDef()))
-        << "Function " << function.name() << " argument " << i;
-    *callee_stack_frame->mutable_local(i) = std::move(arg);
-  }
-
-  // TODO(benvanik): change to:
-  //   get command queue (any command queue)
-  //   make command buffer
-  //   record dispatch
-  //   submit
-  //   wait on fence
-  ASSIGN_OR_RETURN(auto placement,
-                   instance_->device_manager()->ResolvePlacement({}));
-  RETURN_IF_ERROR(
-      DispatchSequence(placement, stack, callee_stack_frame, results));
-
-  // Pop the callee frame to balance out the stack.
-  RETURN_IF_ERROR(stack->PopFrame());
-
-  return OkStatus();
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/sequencer_context.h b/iree/vm/sequencer_context.h
deleted file mode 100644
index dbc4bc9..0000000
--- a/iree/vm/sequencer_context.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_SEQUENCER_CONTEXT_H_
-#define IREE_VM_SEQUENCER_CONTEXT_H_
-
-#include <memory>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/hal/buffer_view.h"
-#include "iree/vm/context.h"
-#include "iree/vm/fiber_state.h"
-#include "iree/vm/function.h"
-#include "iree/vm/instance.h"
-#include "iree/vm/module.h"
-
-namespace iree {
-namespace vm {
-
-class SequencerContext final : public Context {
- public:
-  explicit SequencerContext(std::shared_ptr<Instance> instance);
-  ~SequencerContext() override;
-
-  Status RegisterNativeFunction(std::string name,
-                                NativeFunction native_function) override;
-
-  Status RegisterModule(std::unique_ptr<Module> module) override;
-
-  // TODO(benvanik): helpers to make passing args easier
-  Status Invoke(FiberState* fiber_state, vm::Function function,
-                absl::Span<hal::BufferView> args,
-                absl::Span<hal::BufferView> results) const;
-
- private:
-  std::shared_ptr<Instance> instance_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_CONTEXT_H_
diff --git a/iree/vm/sequencer_dispatch.cc b/iree/vm/sequencer_dispatch.cc
index 90065b9..ce5a408 100644
--- a/iree/vm/sequencer_dispatch.cc
+++ b/iree/vm/sequencer_dispatch.cc
@@ -32,10 +32,10 @@
 #include "iree/hal/device.h"
 #include "iree/hal/heap_buffer.h"
 #include "iree/schemas/bytecode/sequencer_bytecode_v0.h"
+#include "iree/vm/bytecode_module.h"
 #include "iree/vm/bytecode_reader.h"
 #include "iree/vm/bytecode_tables_sequencer.h"
 #include "iree/vm/bytecode_util.h"
-#include "iree/vm/function.h"
 #include "iree/vm/opcode_info.h"
 
 namespace iree {
@@ -65,15 +65,17 @@
 }
 
 // TODO(benvanik): insert fence callbacks and wait on fence.
-Status CallNativeFunction(Stack* stack, const ImportFunction& function) {
-  auto* stack_frame = stack->current_frame();
-
+Status CallExternalFunction(rt::Stack* stack, const rt::Function& function) {
   // Marshal inputs and outputs.
-  auto args = stack_frame->mutable_locals().subspan(0, function.input_count());
-  auto results = stack_frame->mutable_locals().subspan(args.size());
-
-  const auto& fn = function.native_function();
-  return fn(stack, args, results);
+  const auto* stack_frame = stack->current_frame();
+  auto buffer_views = absl::MakeSpan(stack_frame->registers().buffer_views);
+  absl::InlinedVector<hal::BufferView, 8> arguments(
+      buffer_views.begin(),
+      buffer_views.begin() + function.signature().argument_count());
+  absl::InlinedVector<hal::BufferView, 8> results(
+      buffer_views.begin() + arguments.size(), buffer_views.end());
+  return function.module()->Execute(stack, function, std::move(arguments),
+                                    &results);
 }
 
 // Pretty prints an array, e.g. [1, 2, 3, 4]
@@ -109,8 +111,8 @@
 
 }  // namespace
 
-Status DispatchSequence(const hal::DevicePlacement& placement, Stack* stack,
-                        StackFrame* entry_stack_frame,
+Status DispatchSequence(const hal::DevicePlacement& placement, rt::Stack* stack,
+                        rt::StackFrame* entry_stack_frame,
                         absl::Span<BufferView> entry_results) {
   // Dispatch table mapping 1:1 with bytecode ops.
   // Each entry is a label within this function that can be used for computed
@@ -164,7 +166,15 @@
   DISPATCH_CORE_OPCODE(kCall, {
     auto* old_stack_frame = stack->current_frame();
     ASSIGN_OR_RETURN(const auto& target_function, reader.ReadFunction());
+    // TODO(benvanik): rework register storage interface.
+    ASSIGN_OR_RETURN(
+        const auto* function_def,
+        static_cast<const BytecodeModule*>(target_function.module())
+            ->GetFunctionDef(target_function.linkage(),
+                             target_function.ordinal()));
     ASSIGN_OR_RETURN(auto* new_stack_frame, stack->PushFrame(target_function));
+    new_stack_frame->mutable_registers()->buffer_views.resize(
+        function_def->bytecode()->local_count());
     RETURN_IF_ERROR(
         reader.CopyInputsAndSwitchStackFrame(old_stack_frame, new_stack_frame));
     DVLOG(1) << "Call; stack now: " << stack->DebugString();
@@ -172,30 +182,20 @@
 
   DISPATCH_CORE_OPCODE(kCallImport, {
     auto* old_stack_frame = stack->current_frame();
-    ASSIGN_OR_RETURN(const auto* target_function, reader.ReadImportFunction());
-    switch (target_function->link_type()) {
-      case ImportFunction::LinkType::kModule: {
-        ASSIGN_OR_RETURN(auto* new_stack_frame,
-                         stack->PushFrame(target_function->linked_function()));
-        RETURN_IF_ERROR(reader.CopyInputsAndSwitchStackFrame(old_stack_frame,
-                                                             new_stack_frame));
-        DVLOG(1) << "Call module import; stack now: " << stack->DebugString();
-        break;
-      }
-      case ImportFunction::LinkType::kNativeFunction: {
-        ASSIGN_OR_RETURN(auto* new_stack_frame,
-                         stack->PushFrame(*target_function));
-        RETURN_IF_ERROR(reader.CopyInputsAndSwitchStackFrame(old_stack_frame,
-                                                             new_stack_frame));
-        DVLOG(1) << "Call native import; stack now: " << stack->DebugString();
-        RETURN_IF_ERROR(CallNativeFunction(stack, *target_function));
-        RETURN_IF_ERROR(reader.CopyResultsAndSwitchStackFrame(old_stack_frame,
-                                                              new_stack_frame));
-        RETURN_IF_ERROR(stack->PopFrame());
-        DVLOG(1) << "Return from native; stack now: " << stack->DebugString();
-        break;
-      }
-    }
+    ASSIGN_OR_RETURN(const auto& target_function, reader.ReadImportFunction());
+    ASSIGN_OR_RETURN(auto* new_stack_frame, stack->PushFrame(target_function));
+    // TODO(benvanik): rework register storage interface.
+    const auto& signature = target_function.signature();
+    new_stack_frame->mutable_registers()->buffer_views.resize(
+        signature.argument_count() + signature.result_count());
+    RETURN_IF_ERROR(
+        reader.CopyInputsAndSwitchStackFrame(old_stack_frame, new_stack_frame));
+    DVLOG(1) << "Call native import; stack now: " << stack->DebugString();
+    RETURN_IF_ERROR(CallExternalFunction(stack, target_function));
+    RETURN_IF_ERROR(reader.CopyResultsAndSwitchStackFrame(old_stack_frame,
+                                                          new_stack_frame));
+    RETURN_IF_ERROR(stack->PopFrame());
+    DVLOG(1) << "Return from native; stack now: " << stack->DebugString();
   });
 
   DISPATCH_CORE_OPCODE(kCallIndirect, {
@@ -209,8 +209,9 @@
       // Returning from entry function. Marshal results from the return stmt.
       ASSIGN_OR_RETURN(int32_t src_count, reader.ReadCount());
       for (int i = 0; i < src_count; ++i) {
-        ASSIGN_OR_RETURN(auto* src_local,
-                         reader.ReadLocal(old_stack_frame->mutable_locals()));
+        ASSIGN_OR_RETURN(
+            auto* src_local,
+            reader.ReadLocal(old_stack_frame->mutable_registers()));
         entry_results[i] = std::move(*src_local);
       }
       DVLOG(1) << "Returning to entry";
@@ -259,11 +260,10 @@
     // TODO(benvanik): the real sequencer :)
     ASSIGN_OR_RETURN(auto dispatch_ordinal, reader.ReadInt32());
     ASSIGN_OR_RETURN(auto export_ordinal, reader.ReadUint16_t());
-    auto& executable_table =
-        stack->current_frame()->module().executable_table();
     ASSIGN_OR_RETURN(
-        auto* multi_arch_executable_def,
-        executable_table.LookupMultiArchExecutable(dispatch_ordinal));
+        const auto* multi_arch_executable_def,
+        static_cast<const BytecodeModule&>(stack->current_frame()->module())
+            .LookupMultiArchExecutable(dispatch_ordinal));
     if (export_ordinal >= multi_arch_executable_def->entry_point_count()) {
       return InvalidArgumentErrorBuilder(IREE_LOC)
              << "Invalid executable export ordinal " << export_ordinal;
diff --git a/iree/vm/sequencer_dispatch.h b/iree/vm/sequencer_dispatch.h
index fc664db..0251c17 100644
--- a/iree/vm/sequencer_dispatch.h
+++ b/iree/vm/sequencer_dispatch.h
@@ -18,15 +18,15 @@
 #include "iree/base/status.h"
 #include "iree/hal/buffer_view.h"
 #include "iree/hal/device_placement.h"
-#include "iree/vm/stack.h"
-#include "iree/vm/stack_frame.h"
+#include "iree/rt/stack.h"
+#include "iree/rt/stack_frame.h"
 
 namespace iree {
 namespace vm {
 
 // TODO(benvanik): API that supports yielding.
-Status DispatchSequence(const hal::DevicePlacement& placement, Stack* stack,
-                        StackFrame* entry_stack_frame,
+Status DispatchSequence(const hal::DevicePlacement& placement, rt::Stack* stack,
+                        rt::StackFrame* entry_stack_frame,
                         absl::Span<hal::BufferView> entry_results);
 
 }  // namespace vm
diff --git a/iree/vm/sequencer_module.cc b/iree/vm/sequencer_module.cc
new file mode 100644
index 0000000..1906ef6
--- /dev/null
+++ b/iree/vm/sequencer_module.cc
@@ -0,0 +1,112 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "iree/vm/sequencer_module.h"
+
+#include "absl/memory/memory.h"
+#include "iree/base/status.h"
+#include "iree/base/tracing.h"
+#include "iree/hal/buffer_view.h"
+#include "iree/rt/context.h"
+#include "iree/rt/instance.h"
+#include "iree/vm/bytecode_tables_sequencer.h"
+#include "iree/vm/sequencer_dispatch.h"
+
+namespace iree {
+namespace vm {
+
+namespace {
+
+using ::iree::hal::BufferView;
+using ::iree::rt::Function;
+using ::iree::rt::Module;
+
+}  // namespace
+
+// static
+StatusOr<ref_ptr<rt::Module>> SequencerModule::FromDef(
+    const ModuleDef& module_def) {
+  ASSIGN_OR_RETURN(auto module_file, ModuleFile::Create(&module_def, []() {}));
+  return FromFile(std::move(module_file));
+}
+
+// static
+StatusOr<ref_ptr<rt::Module>> SequencerModule::FromFile(
+    std::unique_ptr<ModuleFile> module_file) {
+  if (module_file->root() == nullptr) {
+    return InvalidArgumentErrorBuilder(IREE_LOC) << "No root ModuleDef present";
+  }
+  const auto& module_def = *module_file->root();
+
+  // Validates the structure of the module (but not bytecode).
+  // This ensures we don't have flatbuffer vectors will null entries, etc.
+  RETURN_IF_ERROR(BytecodeModule::ValidateStructure(module_def));
+
+  auto module = assign_ref(new SequencerModule(std::move(module_file)));
+
+  // TODO(benvanik): validate internals here? or make explicit?
+
+  return {std::move(module)};
+}
+
+SequencerModule::SequencerModule(std::unique_ptr<ModuleFile> module_file)
+    : BytecodeModule(std::move(module_file), sequencer_opcode_table()) {}
+
+SequencerModule::~SequencerModule() = default;
+
+Status SequencerModule::Execute(
+    rt::Stack* stack, const Function function,
+    absl::InlinedVector<hal::BufferView, 8> arguments,
+    absl::InlinedVector<hal::BufferView, 8>* results) const {
+  IREE_TRACE_SCOPE0("SequencerModule::Execute");
+
+  // Push stack frame for the function we are calling.
+  ASSIGN_OR_RETURN(auto* callee_stack_frame, stack->PushFrame(function));
+
+  // TODO(benvanik): rework register storage interface.
+  ASSIGN_OR_RETURN(const auto* function_def,
+                   GetFunctionDef(function.linkage(), function.ordinal()));
+  auto* registers = callee_stack_frame->mutable_registers();
+  registers->buffer_views.resize(function_def->bytecode()->local_count());
+
+  // Marshal input arguments.
+  for (int i = 0; i < arguments.size(); ++i) {
+    auto arg = arguments[i];
+    auto expected_arg_type = function_def->type()->inputs()->Get(i);
+    RETURN_IF_ERROR(BytecodeModule::ValidateArgType(
+        arg, *expected_arg_type->type_union_as_MemRefTypeDef()))
+        << "Function " << function.name() << " argument " << i;
+    registers->buffer_views[i] = std::move(arg);
+  }
+
+  // TODO(benvanik): change to:
+  //   get command queue (any command queue)
+  //   make command buffer
+  //   record dispatch
+  //   submit
+  //   wait on fence
+  ASSIGN_OR_RETURN(
+      auto placement,
+      stack->context()->instance()->device_manager()->ResolvePlacement({}));
+  RETURN_IF_ERROR(
+      DispatchSequence(placement, stack, callee_stack_frame, results));
+
+  // Pop the callee frame to balance out the stack.
+  RETURN_IF_ERROR(stack->PopFrame());
+
+  return OkStatus();
+}
+
+}  // namespace vm
+}  // namespace iree
diff --git a/iree/vm/sequencer_module.h b/iree/vm/sequencer_module.h
new file mode 100644
index 0000000..b9bb176
--- /dev/null
+++ b/iree/vm/sequencer_module.h
@@ -0,0 +1,46 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_VM_SEQUENCER_MODULE_H_
+#define IREE_VM_SEQUENCER_MODULE_H_
+
+#include <memory>
+
+#include "iree/vm/bytecode_module.h"
+
+namespace iree {
+namespace vm {
+
+// A module using the sequencer bytecode ops.
+class SequencerModule final : public BytecodeModule {
+ public:
+  static StatusOr<ref_ptr<rt::Module>> FromDef(const ModuleDef& module_def);
+  static StatusOr<ref_ptr<rt::Module>> FromFile(
+      std::unique_ptr<ModuleFile> module_file);
+
+  ~SequencerModule() override;
+
+  Status Execute(
+      rt::Stack* stack, const rt::Function function,
+      absl::InlinedVector<hal::BufferView, 8> arguments,
+      absl::InlinedVector<hal::BufferView, 8>* results) const override;
+
+ private:
+  explicit SequencerModule(std::unique_ptr<ModuleFile> module_file);
+};
+
+}  // namespace vm
+}  // namespace iree
+
+#endif  // IREE_VM_SEQUENCER_MODULE_H_
diff --git a/iree/vm/source_map.h b/iree/vm/source_map.h
deleted file mode 100644
index 32cd41e..0000000
--- a/iree/vm/source_map.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_SOURCE_MAP_H_
-#define IREE_VM_SOURCE_MAP_H_
-
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "iree/base/status.h"
-#include "iree/schemas/module_def_generated.h"
-#include "iree/schemas/source_map_def_generated.h"
-
-namespace iree {
-namespace vm {
-
-class SourceLocation {
- public:
-  static bool Equal(const SourceLocation& a, const SourceLocation& b);
-
-  SourceLocation() = default;
-  SourceLocation(const SourceMapDef& source_map_def,
-                 const FunctionSourceMapDef& function_source_map,
-                 int location_ordinal)
-      : source_map_def_(&source_map_def),
-        function_source_map_(&function_source_map),
-        location_ordinal_(location_ordinal) {}
-
-  std::string DebugStringShort() const;
-
-  bool empty() const { return source_map_def_ == nullptr; }
-
- private:
-  const SourceMapDef* source_map_def_ = nullptr;
-  const FunctionSourceMapDef* function_source_map_ = nullptr;
-  int location_ordinal_ = 0;
-};
-
-inline bool operator==(const SourceLocation& a, const SourceLocation& b) {
-  return SourceLocation::Equal(a, b);
-}
-
-inline bool operator!=(const SourceLocation& a, const SourceLocation& b) {
-  return !(a == b);
-}
-
-class SourceMap {
- public:
-  static SourceMap FromModule(const ModuleDef& module_def);
-
-  SourceMap() = default;
-  explicit SourceMap(const SourceMapDef& source_map_def)
-      : source_map_def_(&source_map_def) {}
-
-  bool empty() const { return source_map_def_ == nullptr; }
-  const SourceMapDef* def() const { return source_map_def_; }
-
-  StatusOr<absl::string_view> GetUniqueString(int string_index) const;
-
-  StatusOr<const FunctionSourceMapDef*> GetFunctionSourceMap(
-      int function_ordinal) const;
-
- private:
-  const SourceMapDef* source_map_def_ = nullptr;
-};
-inline std::ostream& operator<<(std::ostream& stream,
-                                const SourceLocation& location) {
-  stream << location.DebugStringShort();
-  return stream;
-}
-
-class SourceMapResolver {
- public:
-  static SourceMapResolver FromFunction(const ModuleDef& module_def,
-                                        int function_ordinal);
-
-  SourceMapResolver() = default;
-
-  absl::optional<SourceLocation> ResolveBytecodeOffset(int offset) const;
-
- private:
-  SourceMapResolver(SourceMap source_map,
-                    const FunctionSourceMapDef& function_source_map)
-      : source_map_(std::move(source_map)),
-        function_source_map_(&function_source_map) {}
-
-  SourceMap source_map_;
-  const FunctionSourceMapDef* function_source_map_ = nullptr;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_SOURCE_MAP_H_
diff --git a/iree/vm/source_map.cc b/iree/vm/source_map_resolver.cc
similarity index 72%
rename from iree/vm/source_map.cc
rename to iree/vm/source_map_resolver.cc
index 4b8467f..96025e4 100644
--- a/iree/vm/source_map.cc
+++ b/iree/vm/source_map_resolver.cc
@@ -12,23 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "iree/vm/source_map.h"
-
-#include <sstream>
+#include "iree/vm/source_map_resolver.h"
 
 #include "iree/base/flatbuffer_util.h"
 #include "iree/base/status.h"
+#include "iree/schemas/source_map_def_generated.h"
 
 namespace iree {
 namespace vm {
 
 namespace {
 
-Status PrintLocation(const SourceMap& source_map,
+Status PrintLocation(const SourceMapResolver& source_map,
                      const FunctionSourceMapDef& function_source_map,
                      const LocationDef& location, std::ostream* stream);
 
-Status PrintFileLocation(const SourceMap& source_map,
+Status PrintFileLocation(const SourceMapResolver& source_map,
                          const FunctionSourceMapDef& function_source_map,
                          const FileLocationDef& location,
                          std::ostream* stream) {
@@ -38,7 +37,7 @@
   return OkStatus();
 }
 
-Status PrintNameLocation(const SourceMap& source_map,
+Status PrintNameLocation(const SourceMapResolver& source_map,
                          const FunctionSourceMapDef& function_source_map,
                          const NameLocationDef& location,
                          std::ostream* stream) {
@@ -47,7 +46,7 @@
   return OkStatus();
 }
 
-Status PrintCallSiteLocation(const SourceMap& source_map,
+Status PrintCallSiteLocation(const SourceMapResolver& source_map,
                              const FunctionSourceMapDef& function_source_map,
                              const CallSiteLocationDef& location,
                              std::ostream* stream) {
@@ -55,7 +54,7 @@
   return OkStatus();
 }
 
-Status PrintFusedLocation(const SourceMap& source_map,
+Status PrintFusedLocation(const SourceMapResolver& source_map,
                           const FunctionSourceMapDef& function_source_map,
                           const FusedLocationDef& location,
                           std::ostream* stream) {
@@ -74,7 +73,7 @@
   return OkStatus();
 }
 
-Status PrintLocation(const SourceMap& source_map,
+Status PrintLocation(const SourceMapResolver& source_map,
                      const FunctionSourceMapDef& function_source_map,
                      const LocationDef& location, std::ostream* stream) {
   switch (location.location_union_type()) {
@@ -104,36 +103,15 @@
 }  // namespace
 
 // static
-bool SourceLocation::Equal(const SourceLocation& a, const SourceLocation& b) {
-  return a.source_map_def_ == b.source_map_def_ &&
-         a.function_source_map_ == b.function_source_map_ &&
-         a.location_ordinal_ == b.location_ordinal_;
-}
-
-std::string SourceLocation::DebugStringShort() const {
-  if (empty()) {
-    return "<unknown>";
-  }
-  std::ostringstream stream;
-  const auto& location =
-      *function_source_map_->location_table()->Get(location_ordinal_);
-  auto status = PrintLocation(SourceMap(*source_map_def_),
-                              *function_source_map_, location, &stream);
-  if (!status.ok()) {
-    stream << status;
-  }
-  return stream.str();
-}
-
-// static
-SourceMap SourceMap::FromModule(const ModuleDef& module_def) {
+SourceMapResolver SourceMapResolver::FromModule(const ModuleDef& module_def) {
   if (module_def.source_map()) {
-    return SourceMap{*module_def.source_map()};
+    return SourceMapResolver{*module_def.source_map()};
   }
   return {};
 }
 
-StatusOr<absl::string_view> SourceMap::GetUniqueString(int string_index) const {
+StatusOr<absl::string_view> SourceMapResolver::GetUniqueString(
+    int string_index) const {
   if (empty()) {
     return NotFoundErrorBuilder(IREE_LOC) << "No source map present";
   }
@@ -145,7 +123,7 @@
          << "String index " << string_index << " not present in string table";
 }
 
-StatusOr<const FunctionSourceMapDef*> SourceMap::GetFunctionSourceMap(
+StatusOr<const FunctionSourceMapDef*> SourceMapResolver::GetFunctionSourceMap(
     int function_ordinal) const {
   if (empty()) {
     return NotFoundErrorBuilder(IREE_LOC) << "No source map present";
@@ -163,28 +141,16 @@
          << " source map not present in function table";
 }
 
-// static
-SourceMapResolver SourceMapResolver::FromFunction(const ModuleDef& module_def,
-                                                  int function_ordinal) {
-  auto source_map = SourceMap::FromModule(module_def);
-  if (source_map.empty()) {
-    return {};
-  }
-  auto function_source_map_or =
-      source_map.GetFunctionSourceMap(function_ordinal);
+absl::optional<rt::SourceLocation> SourceMapResolver::ResolveFunctionOffset(
+    const rt::Function& function, rt::SourceOffset offset) {
+  if (empty()) return absl::nullopt;
+  auto function_source_map_or = GetFunctionSourceMap(function.ordinal());
   if (!function_source_map_or.ok()) {
-    return {};
+    return absl::nullopt;
   }
-  return SourceMapResolver(source_map, *function_source_map_or.ValueOrDie());
-}
-
-absl::optional<SourceLocation> SourceMapResolver::ResolveBytecodeOffset(
-    int offset) const {
-  if (!function_source_map_) {
-    return {};
-  }
-
-  const auto* bytecode_map = function_source_map_->bytecode_map();
+  const auto* function_source_map = function_source_map_or.ValueOrDie();
+  const auto* bytecode_map = function_source_map->bytecode_map();
+  if (!bytecode_map) return absl::nullopt;
 
   // TODO(benvanik): allow fuzzy offset matching/table sparsity.
   int location_ordinal = -1;
@@ -195,11 +161,33 @@
     }
   }
   if (location_ordinal == -1) {
-    return {};
+    return absl::nullopt;
   }
 
-  return SourceLocation(*source_map_.def(), *function_source_map_,
-                        location_ordinal);
+  return rt::SourceLocation(this,
+                            {
+                                reinterpret_cast<uint64_t>(function_source_map),
+                                static_cast<uint64_t>(location_ordinal),
+                            });
+}
+
+void SourceMapResolver::PrintSourceLocation(
+    rt::SourceResolverArgs resolver_args, std::ostream* stream) const {
+  if (empty()) {
+    *stream << "<unknown>";
+    return;
+  }
+
+  auto* function_source_map =
+      reinterpret_cast<FunctionSourceMapDef*>(resolver_args[0]);
+  int location_ordinal = static_cast<int>(resolver_args[1]);
+
+  const auto& location =
+      *function_source_map->location_table()->Get(location_ordinal);
+  auto status = PrintLocation(*this, *function_source_map, location, stream);
+  if (!status.ok()) {
+    *stream << status;
+  }
 }
 
 }  // namespace vm
diff --git a/iree/vm/source_map_resolver.h b/iree/vm/source_map_resolver.h
new file mode 100644
index 0000000..5c8f7c2
--- /dev/null
+++ b/iree/vm/source_map_resolver.h
@@ -0,0 +1,57 @@
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_VM_SOURCE_MAP_RESOLVER_H_
+#define IREE_VM_SOURCE_MAP_RESOLVER_H_
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "iree/base/status.h"
+#include "iree/rt/source_resolver.h"
+#include "iree/schemas/module_def_generated.h"
+#include "iree/schemas/source_map_def_generated.h"
+
+namespace iree {
+namespace vm {
+
+class SourceMapResolver final : public rt::SourceResolver {
+ public:
+  static SourceMapResolver FromModule(const ModuleDef& module_def);
+
+  SourceMapResolver() = default;
+  explicit SourceMapResolver(const SourceMapDef& source_map_def)
+      : source_map_def_(&source_map_def) {}
+
+  bool empty() const { return source_map_def_ == nullptr; }
+  const SourceMapDef* def() const { return source_map_def_; }
+
+  StatusOr<absl::string_view> GetUniqueString(int string_index) const;
+
+  StatusOr<const FunctionSourceMapDef*> GetFunctionSourceMap(
+      int function_ordinal) const;
+
+  absl::optional<rt::SourceLocation> ResolveFunctionOffset(
+      const rt::Function& function, rt::SourceOffset offset) override;
+
+  void PrintSourceLocation(rt::SourceResolverArgs resolver_args,
+                           std::ostream* stream) const override;
+
+ private:
+  const SourceMapDef* source_map_def_ = nullptr;
+};
+
+}  // namespace vm
+}  // namespace iree
+
+#endif  // IREE_VM_SOURCE_MAP_RESOLVER_H_
diff --git a/iree/vm/stack.cc b/iree/vm/stack.cc
deleted file mode 100644
index 5912173..0000000
--- a/iree/vm/stack.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/stack.h"
-
-#include <iterator>
-
-#include "absl/strings/str_join.h"
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-constexpr int Stack::kMaxStackDepth;
-
-Stack::Stack() = default;
-
-Stack::~Stack() = default;
-
-StatusOr<StackFrame*> Stack::PushFrame(Function function) {
-  if (stack_depth_ + 1 > kMaxStackDepth) {
-    return InternalErrorBuilder(IREE_LOC)
-           << "Max stack depth of " << kMaxStackDepth << " exceeded";
-  }
-  stack_[stack_depth_++] = StackFrame(function);
-
-  // TODO(benvanik): WTF scope enter.
-
-  return current_frame();
-}
-
-StatusOr<StackFrame*> Stack::PushFrame(const ImportFunction& function) {
-  if (stack_depth_ + 1 > kMaxStackDepth) {
-    return InternalErrorBuilder(IREE_LOC)
-           << "Max stack depth of " << kMaxStackDepth << " exceeded";
-  }
-  stack_[stack_depth_++] = StackFrame(function);
-
-  // TODO(benvanik): WTF scope enter.
-
-  return current_frame();
-}
-
-Status Stack::PopFrame() {
-  if (stack_depth_ == 0) {
-    return InternalErrorBuilder(IREE_LOC) << "Unbalanced stack pop";
-  }
-
-  // TODO(benvanik): WTF scope leave.
-
-  --stack_depth_;
-  return OkStatus();
-}
-
-namespace {
-struct StackFrameFormatter {
-  void operator()(std::string* out, const StackFrame& stack_frame) const {
-    out->append(absl::StrCat(stack_frame.module().name(), ":",
-                             stack_frame.function().name(), "@",
-                             stack_frame.offset()));
-  }
-};
-}  // namespace
-
-std::string Stack::DebugString() const {
-  return absl::StrJoin(std::begin(stack_), std::begin(stack_) + stack_depth_,
-                       "\n", StackFrameFormatter());
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/stack.h b/iree/vm/stack.h
deleted file mode 100644
index 7228742..0000000
--- a/iree/vm/stack.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_STACK_H_
-#define IREE_VM_STACK_H_
-
-#include <functional>
-
-#include "absl/types/span.h"
-#include "iree/base/status.h"
-#include "iree/vm/stack_frame.h"
-
-namespace iree {
-namespace vm {
-
-// VM call stack.
-//
-// Stacks are thread-compatible.
-class Stack {
- public:
-  static constexpr int kMaxStackDepth = 32;
-
-  Stack();
-  Stack(const Stack&) = delete;
-  Stack& operator=(const Stack&) = delete;
-  ~Stack();
-
-  absl::Span<const StackFrame> frames() const {
-    return absl::MakeConstSpan(stack_, stack_depth_);
-  }
-  absl::Span<StackFrame> mutable_frames() {
-    return absl::MakeSpan(stack_, stack_depth_);
-  }
-
-  StackFrame* current_frame() {
-    return stack_depth_ > 0 ? &stack_[stack_depth_ - 1] : nullptr;
-  }
-  const StackFrame* current_frame() const {
-    return stack_depth_ > 0 ? &stack_[stack_depth_ - 1] : nullptr;
-  }
-  StackFrame* caller_frame() {
-    return stack_depth_ > 1 ? &stack_[stack_depth_ - 2] : nullptr;
-  }
-  const StackFrame* caller_frame() const {
-    return stack_depth_ > 1 ? &stack_[stack_depth_ - 2] : nullptr;
-  }
-
-  StatusOr<StackFrame*> PushFrame(Function function);
-  StatusOr<StackFrame*> PushFrame(const ImportFunction& function);
-  Status PopFrame();
-
-  std::string DebugString() const;
-
- private:
-  StackFrame stack_[kMaxStackDepth];
-  int stack_depth_ = 0;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_STACK_H_
diff --git a/iree/vm/stack_frame.cc b/iree/vm/stack_frame.cc
deleted file mode 100644
index 3974470..0000000
--- a/iree/vm/stack_frame.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "iree/vm/stack_frame.h"
-
-#include "iree/base/status.h"
-
-namespace iree {
-namespace vm {
-
-StackFrame::StackFrame(Function function) : function_(function) {
-  const auto* bytecode_def = function_.def().bytecode();
-  if (bytecode_def) {
-    offset_limit_ = bytecode_def->contents()->Length();
-    locals_.resize(bytecode_def->local_count());
-  } else {
-    locals_.resize(function_.input_count() + function_.result_count());
-  }
-}
-
-StackFrame::StackFrame(const ImportFunction& function)
-    : function_(function), import_function_(&function) {}
-
-Status StackFrame::set_offset(int offset) {
-  if (offset < 0 || offset > offset_limit_) {
-    return OutOfRangeErrorBuilder(IREE_LOC)
-           << "Offset " << offset
-           << " is outside of the bytecode body limit of " << offset_limit_;
-  }
-  offset_ = offset;
-  return OkStatus();
-}
-
-}  // namespace vm
-}  // namespace iree
diff --git a/iree/vm/stack_frame.h b/iree/vm/stack_frame.h
deleted file mode 100644
index a39c789..0000000
--- a/iree/vm/stack_frame.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef IREE_VM_STACK_FRAME_H_
-#define IREE_VM_STACK_FRAME_H_
-
-#include <vector>
-
-#include "absl/types/span.h"
-#include "iree/hal/buffer_view.h"
-#include "iree/vm/function.h"
-#include "iree/vm/module.h"
-
-namespace iree {
-namespace vm {
-
-// A single frame on the call stack containing current execution state and
-// local values.
-//
-// StackFrames are designed to be serialized so that suspend and resume is
-// possible. This means that most state is stored either entirely within the
-// frame or references to non-pointer values (such as other function indices).
-// BufferViews require special care to allow rendezvous and liveness tracking.
-class StackFrame {
- public:
-  StackFrame() = default;
-  explicit StackFrame(Function function);
-  explicit StackFrame(const ImportFunction& function);
-  StackFrame(const StackFrame&) = delete;
-  StackFrame& operator=(const StackFrame&) = delete;
-  StackFrame(StackFrame&&) = default;
-  StackFrame& operator=(StackFrame&&) = default;
-
-  const Module& module() const { return function_.module(); }
-  const Function& function() const { return function_; }
-
-  inline int offset() const { return offset_; }
-  Status set_offset(int offset);
-  inline int* mutable_offset() { return &offset_; }
-
-  inline const hal::BufferView& local(int ordinal) { return locals_[ordinal]; }
-  inline hal::BufferView* mutable_local(int ordinal) {
-    return &locals_[ordinal];
-  }
-
-  inline absl::Span<const hal::BufferView> locals() const {
-    return absl::MakeConstSpan(locals_);
-  }
-  inline absl::Span<hal::BufferView> mutable_locals() {
-    return absl::MakeSpan(locals_);
-  }
-
- private:
-  Function function_;
-  const ImportFunction* import_function_;
-  int offset_ = 0;
-  int offset_limit_ = 0;
-
-  // TODO(benvanik): replace with a placed allocation.
-  std::vector<hal::BufferView> locals_;
-};
-
-}  // namespace vm
-}  // namespace iree
-
-#endif  // IREE_VM_STACK_FRAME_H_