From d0c5fc290611c228ecb79c2e9d3a12c4359bad64 Mon Sep 17 00:00:00 2001
From: Yuhan Deng <yhdeng@stanford.edu>
Date: Tue, 29 Mar 2022 17:59:39 -0700
Subject: [PATCH 1/9] Fix register command for named modules

---
 test/run-spec-wasm2c.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/run-spec-wasm2c.py b/test/run-spec-wasm2c.py
index e32c90781..59c50ed98 100755
--- a/test/run-spec-wasm2c.py
+++ b/test/run-spec-wasm2c.py
@@ -122,6 +122,7 @@ def __init__(self, spec_json, prefix, out_file, out_dir):
         self.module_name_to_idx = {}
         self.module_prefix_map = {}
         self.unmangled_names = {}
+        self.idx_to_module_name = {}
         self._MaybeWriteDummyModule()
         self._CacheModulePrefixes()
 
@@ -162,6 +163,7 @@ def _CacheModulePrefixes(self):
 
                 if 'name' in command:
                     self.module_name_to_idx[command['name']] = idx
+                    self.idx_to_module_name[idx] = command['name']
                     self.module_prefix_map[command['name']] = name
 
                 idx += 1
@@ -173,6 +175,8 @@ def _CacheModulePrefixes(self):
                 else:
                     name_idx = idx - 1
 
+                if name_idx in self.idx_to_module_name:
+                    self.module_prefix_map[self.idx_to_module_name[name_idx]] = name
                 self.module_prefix_map[name_idx] = name
                 self.unmangled_names[name_idx] = command['as']
 

From 9943a8f36667f34388a6c67b56ad8638d0f8fae5 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Fri, 15 Jul 2022 01:10:32 -0500
Subject: [PATCH 2/9] gen-wasm2c-templates.cmake: use line-by-line string to
 work around MSVC limit

---
 scripts/gen-wasm2c-templates.cmake | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/gen-wasm2c-templates.cmake b/scripts/gen-wasm2c-templates.cmake
index 99a61d039..3fc387f95 100644
--- a/scripts/gen-wasm2c-templates.cmake
+++ b/scripts/gen-wasm2c-templates.cmake
@@ -1,4 +1,5 @@
 # https://stackoverflow.com/a/47801116
 file(READ ${in} content)
-set(content "const char* ${symbol} = R\"w2c_template(${content})w2c_template\";")
+string(REGEX REPLACE "(.[^\n]*\n)" "R\"w2c_template(\\1)w2c_template\"\n" content "${content}")
+set(content "const char* ${symbol} = ${content};")
 file(WRITE ${out} "${content}")

From 3493b419e73570ae7142a456d635bc39dd285316 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Thu, 3 Mar 2022 22:25:33 -0800
Subject: [PATCH 3/9] wasm2c: implement bulk memory operations

---
 src/c-writer.cc                    | 300 ++++++++++++++++++++++-------
 src/template/wasm2c.declarations.c |  81 ++++++++
 src/template/wasm2c.includes.c     |   1 +
 src/tools/wasm2c.cc                |   1 -
 wasm2c/examples/fac/fac.c          | 108 ++++++++++-
 wasm2c/wasm-rt.h                   |   4 +-
 6 files changed, 415 insertions(+), 80 deletions(-)

diff --git a/src/c-writer.cc b/src/c-writer.cc
index 0c201b12f..56890ec89 100644
--- a/src/c-writer.cc
+++ b/src/c-writer.cc
@@ -278,6 +278,8 @@ class CWriter {
   void WriteTables();
   void WriteTable(const std::string&);
   void WriteTablePtr(const std::string&);
+  void WriteDataInstances();
+  void WriteElemInstances();
   void WriteGlobalInitializers();
   void WriteDataInitializers();
   void WriteElemInitializers();
@@ -996,6 +998,7 @@ void CWriter::WriteFuncTypes() {
     Writef("static u32 func_types[%" PRIzd "];", module_->types.size());
     Write(Newline());
   }
+  Write(Newline());
   Write("static void init_func_types(void) ", OpenBrace());
   if (!module_->types.size()) {
     Write(CloseBrace(), Newline());
@@ -1285,6 +1288,8 @@ void CWriter::WriteModuleInstance() {
   WriteGlobals();
   WriteMemories();
   WriteTables();
+  WriteDataInstances();
+  WriteElemInstances();
 
   // C forbids an empty struct
   if (module_->globals.empty() && module_->memories.empty() &&
@@ -1385,21 +1390,35 @@ void CWriter::WriteGlobalInitializers() {
   Write(CloseBrace(), Newline());
 }
 
-void CWriter::WriteDataInitializers() {
-  const Memory* memory = nullptr;
-  Index data_segment_index = 0;
+static inline bool is_droppable(const DataSegment* data_segment) {
+  return (data_segment->kind == SegmentKind::Passive) &&
+         (!data_segment->data.empty());
+}
+
+static inline bool is_droppable(const ElemSegment* elem_segment) {
+  return (elem_segment->kind == SegmentKind::Passive) &&
+         (!elem_segment->elem_exprs.empty());
+}
+
+void CWriter::WriteDataInstances() {
+  for (const DataSegment* data_segment : module_->data_segments) {
+    DefineGlobalScopeName(data_segment->name);
+    if (is_droppable(data_segment)) {
+      Write("bool ", "data_segment_dropped_", GetGlobalName(data_segment->name),
+            " : 1;", Newline());
+    }
+  }
+}
 
+void CWriter::WriteDataInitializers() {
   if (!module_->memories.empty()) {
     if (module_->data_segments.empty()) {
       Write(Newline());
     } else {
       for (const DataSegment* data_segment : module_->data_segments) {
-        if (!data_segment->data.size()) {
-          Write(Newline(), "static const u8* data_segment_data_",
-                data_segment_index, " = NULL;", Newline());
-        } else {
+        if (data_segment->data.size()) {
           Write(Newline(), "static const u8 data_segment_data_",
-                data_segment_index, "[] = ", OpenBrace());
+                GetGlobalName(data_segment->name), "[] = ", OpenBrace());
           size_t i = 0;
           for (uint8_t x : data_segment->data) {
             Writef("0x%02x, ", x);
@@ -1410,11 +1429,8 @@ void CWriter::WriteDataInitializers() {
             Write(Newline());
           Write(CloseBrace(), ";", Newline());
         }
-        ++data_segment_index;
       }
     }
-
-    memory = module_->memories[0];
   }
 
   Write("static void init_memory(", ModuleInstanceTypeName(), "* instance) ",
@@ -1422,83 +1438,139 @@ void CWriter::WriteDataInitializers() {
   if (module_->memories.size() > module_->num_memory_imports) {
     Index memory_idx = module_->num_memory_imports;
     for (Index i = memory_idx; i < module_->memories.size(); i++) {
-      memory = module_->memories[i];
+      const Memory* memory = module_->memories[i];
       uint32_t max =
           memory->page_limits.has_max ? memory->page_limits.max : 65536;
       Write("wasm_rt_allocate_memory(", ExternalInstancePtr(memory->name), ", ",
             memory->page_limits.initial, ", ", max, ");", Newline());
     }
   }
-  data_segment_index = 0;
   for (const DataSegment* data_segment : module_->data_segments) {
-    Write("LOAD_DATA(", ExternalInstanceRef(memory->name), ", ");
-    WriteInitExpr(data_segment->offset);
-    Write(", data_segment_data_", data_segment_index, ", ",
-          data_segment->data.size());
-    Write(");", Newline());
-    ++data_segment_index;
+    if (data_segment->kind == SegmentKind::Active) {
+      const Memory* memory =
+          module_->memories[module_->GetMemoryIndex(data_segment->memory_var)];
+      Write("LOAD_DATA(", ExternalInstanceRef(memory->name), ", ");
+      WriteInitExpr(data_segment->offset);
+      if (data_segment->data.empty()) {
+        Write(", NULL, 0");
+      } else {
+        Write(", data_segment_data_", GetGlobalName(data_segment->name), ", ",
+              data_segment->data.size());
+      }
+      Write(");", Newline());
+    }
+  }
+
+  Write(CloseBrace(), Newline());
+
+  Write(Newline(), "static void init_data_instances(", ModuleInstanceTypeName(),
+        " *instance) ", OpenBrace());
+
+  for (const DataSegment* data_segment : module_->data_segments) {
+    if (is_droppable(data_segment)) {
+      Write("instance->data_segment_dropped_",
+            GetGlobalName(data_segment->name), " = false;", Newline());
+    }
   }
 
   Write(CloseBrace(), Newline());
 }
 
+void CWriter::WriteElemInstances() {
+  for (const ElemSegment* elem_segment : module_->elem_segments) {
+    DefineGlobalScopeName(elem_segment->name);
+    if (is_droppable(elem_segment)) {
+      Write("bool ", "elem_segment_dropped_", GetGlobalName(elem_segment->name),
+            " : 1;", Newline());
+    }
+  }
+}
+
 void CWriter::WriteElemInitializers() {
-  Write(Newline(), "static void init_table(", ModuleInstanceTypeName(),
-        "* instance) ", OpenBrace());
+  for (const ElemSegment* elem_segment : module_->elem_segments) {
+    if (elem_segment->elem_exprs.empty()) {
+      continue;
+    }
 
-  if (!module_->types.size()) {
-    // If there are no types there cannot be any table entries either.
-    for (const ElemSegment* elem_segment : module_->elem_segments) {
-      assert(elem_segment->elem_exprs.size() == 0);
+    Write(Newline(),
+          "static const wasm_elem_segment_expr_t elem_segment_exprs_",
+          GetGlobalName(elem_segment->name), "[] = ", OpenBrace());
+
+    for (const ExprList& elem_expr : elem_segment->elem_exprs) {
+      assert(elem_expr.size() == 1);
+      const Expr& expr = elem_expr.front();
+      switch (expr.type()) {
+        case ExprType::RefFunc: {
+          const Func* func = module_->GetFunc(cast<RefFuncExpr>(&expr)->var);
+          const Index func_type_index =
+              module_->GetFuncTypeIndex(func->decl.type_var);
+          Write("{", func_type_index, ", ");
+          Write("(wasm_rt_funcref_t)", ExternalPtr(func->name), ", ");
+          const bool is_import = import_module_sym_map_.count(func->name) != 0;
+          if (is_import) {
+            Write("offsetof(", ModuleInstanceTypeName(), ", ",
+                  MangleModuleInstanceName(import_module_sym_map_[func->name]),
+                  ")");
+          } else {
+            Write("0");
+          }
+          Write("}, ", Newline());
+        } break;
+        case ExprType::RefNull:
+          Write("{0, NULL, 0}, ", Newline());
+          break;
+        default:
+          WABT_UNREACHABLE;
+      }
     }
-    Write(CloseBrace(), Newline());
-    return;
+    Write(CloseBrace(), ";", Newline());
   }
+
+  Write(Newline(), "static void init_table(", ModuleInstanceTypeName(),
+        "* instance) ", OpenBrace());
+
   const Table* table = module_->tables.empty() ? nullptr : module_->tables[0];
 
-  Write("uint32_t offset;", Newline());
   if (table && module_->num_table_imports == 0) {
     uint32_t max =
         table->elem_limits.has_max ? table->elem_limits.max : UINT32_MAX;
     Write("wasm_rt_allocate_table(", ExternalInstancePtr(table->name), ", ",
           table->elem_limits.initial, ", ", max, ");", Newline());
   }
-  Index elem_segment_index = 0;
   for (const ElemSegment* elem_segment : module_->elem_segments) {
-    if (elem_segment->kind == SegmentKind::Passive) {
+    if (elem_segment->kind != SegmentKind::Active) {
       continue;
     }
-    Write("offset = ");
+
+    Write("table_init(", ExternalInstancePtr(table->name), ", ");
+    if (elem_segment->elem_exprs.empty()) {
+      Write("NULL, 0, ");
+    } else {
+      Write("elem_segment_exprs_", GetGlobalName(elem_segment->name), ", ",
+            elem_segment->elem_exprs.size(), ", ");
+    }
     WriteInitExpr(elem_segment->offset);
-    Write(";", Newline());
+    if (elem_segment->elem_exprs.empty()) {
+      // It's mandatory to handle the case of a zero-length elem segment
+      // (even in a module with no types). This must trap if the offset
+      // is out of bounds.
+      Write(", 0, 0, instance, NULL);", Newline());
+    } else {
+      Write(", 0, ", elem_segment->elem_exprs.size(),
+            ", instance, func_types);", Newline());
+    }
+  }
 
-    size_t i = 0;
-    for (const ExprList& elem_expr : elem_segment->elem_exprs) {
-      // We don't support the bulk-memory proposal here, so we know that we
-      // don't have any passive segments (where ref.null can be used).
-      assert(elem_expr.size() == 1);
-      const Expr* expr = &elem_expr.front();
-      assert(expr->type() == ExprType::RefFunc);
-      const Func* func = module_->GetFunc(cast<RefFuncExpr>(expr)->var);
-      Index func_type_index = module_->GetFuncTypeIndex(func->decl.type_var);
-
-      bool is_import = import_module_sym_map_.count(func->name) != 0;
-      if (is_import) {
-        Write(ExternalInstanceRef(table->name), ".data[offset + ", i,
-              "] = (wasm_rt_elem_t){func_types[", func_type_index,
-              "], (wasm_rt_funcref_t)", ExternalPtr(func->name),
-              ", (void*)(instance->",
-              MangleModuleInstanceName(import_module_sym_map_[func->name]),
-              ")};", Newline());
-      } else {
-        Write(ExternalInstanceRef(table->name), ".data[offset + ", i,
-              "] = (wasm_rt_elem_t){func_types[", func_type_index,
-              "], (wasm_rt_funcref_t)", ExternalPtr(func->name),
-              ", (void*)instance};", Newline());
-      }
-      ++i;
+  Write(CloseBrace(), Newline());
+
+  Write(Newline(), "static void init_elem_instances(", ModuleInstanceTypeName(),
+        " *instance) ", OpenBrace());
+
+  for (const ElemSegment* elem_segment : module_->elem_segments) {
+    if (is_droppable(elem_segment)) {
+      Write("instance->elem_segment_dropped_",
+            GetGlobalName(elem_segment->name), " = false;", Newline());
     }
-    ++elem_segment_index;
   }
 
   Write(CloseBrace(), Newline());
@@ -1652,6 +1724,8 @@ void CWriter::WriteInit() {
   Write("init_globals(instance);", Newline());
   Write("init_memory(instance);", Newline());
   Write("init_table(instance);", Newline());
+  Write("init_data_instances(instance);", Newline());
+  Write("init_elem_instances(instance);", Newline());
   for (Var* var : module_->starts) {
     Write(ExternalRef(module_->GetFunc(*var)->name));
     bool is_import =
@@ -1715,8 +1789,7 @@ void CWriter::WriteFree() {
   Write(Newline(), "void " + module_prefix_ + "_free(",
         ModuleInstanceTypeName(), "* instance) ", OpenBrace());
 
-  if (module_->types.size()) {
-    // If there are no types there cannot be any table entries either.
+  {
     assert(module_->tables.size() <= 1);
     Index table_index = 0;
     for (const Table* table : module_->tables) {
@@ -2340,13 +2413,104 @@ void CWriter::Write(const ExprList& exprs) {
         break;
       }
 
-      case ExprType::MemoryCopy:
-      case ExprType::DataDrop:
-      case ExprType::MemoryInit:
-      case ExprType::MemoryFill:
-      case ExprType::TableCopy:
-      case ExprType::ElemDrop:
-      case ExprType::TableInit:
+      case ExprType::MemoryFill: {
+        const auto inst = cast<MemoryFillExpr>(&expr);
+        Memory* memory =
+            module_->memories[module_->GetMemoryIndex(inst->memidx)];
+        Write("memory_fill(", ExternalInstancePtr(memory->name), ", ",
+              StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");",
+              Newline());
+        DropTypes(3);
+      } break;
+
+      case ExprType::MemoryCopy: {
+        const auto inst = cast<MemoryCopyExpr>(&expr);
+        Memory* dest_memory =
+            module_->memories[module_->GetMemoryIndex(inst->destmemidx)];
+        const Memory* src_memory = module_->GetMemory(inst->srcmemidx);
+        Write("memory_copy(", ExternalInstancePtr(dest_memory->name), ", ",
+              ExternalInstancePtr(src_memory->name), ", ", StackVar(2), ", ",
+              StackVar(1), ", ", StackVar(0), ");", Newline());
+        DropTypes(3);
+      } break;
+
+      case ExprType::MemoryInit: {
+        const auto inst = cast<MemoryInitExpr>(&expr);
+        Memory* dest_memory =
+            module_->memories[module_->GetMemoryIndex(inst->memidx)];
+        const DataSegment* src_data = module_->GetDataSegment(inst->var);
+        Write("memory_init(", ExternalInstancePtr(dest_memory->name), ", ");
+        if (src_data->data.empty()) {
+          Write("NULL, 0");
+        } else {
+          Write("data_segment_data_", GetGlobalName(src_data->name), ", ");
+          if (is_droppable(src_data)) {
+            Write("(", "instance->data_segment_dropped_",
+                  GetGlobalName(src_data->name),
+                  " ? 0 : ", src_data->data.size(), ")");
+          } else {
+            Write("0");
+          }
+        }
+
+        Write(", ", StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");",
+              Newline());
+        DropTypes(3);
+      } break;
+
+      case ExprType::TableInit: {
+        const auto inst = cast<TableInitExpr>(&expr);
+        Table* dest_table =
+            module_->tables[module_->GetTableIndex(inst->table_index)];
+        const ElemSegment* src_segment =
+            module_->GetElemSegment(inst->segment_index);
+        Write("table_init(", ExternalInstancePtr(dest_table->name), ", ");
+        if (src_segment->elem_exprs.empty()) {
+          Write("NULL, 0");
+        } else {
+          Write("elem_segment_exprs_", GetGlobalName(src_segment->name), ", ");
+          if (is_droppable(src_segment)) {
+            Write("(instance->elem_segment_dropped_",
+                  GetGlobalName(src_segment->name),
+                  " ? 0 : ", src_segment->elem_exprs.size(), ")");
+          } else {
+            Write("0");
+          }
+        }
+
+        Write(", ", StackVar(2), ", ", StackVar(1), ", ", StackVar(0));
+        Write(", instance, func_types);", Newline());
+        DropTypes(3);
+      } break;
+
+      case ExprType::DataDrop: {
+        const auto inst = cast<DataDropExpr>(&expr);
+        const DataSegment* data = module_->GetDataSegment(inst->var);
+        if (is_droppable(data)) {
+          Write("instance->data_segment_dropped_", GetGlobalName(data->name),
+                " = true;", Newline());
+        }
+      } break;
+
+      case ExprType::ElemDrop: {
+        const auto inst = cast<ElemDropExpr>(&expr);
+        const ElemSegment* seg = module_->GetElemSegment(inst->var);
+        if (is_droppable(seg)) {
+          Write("instance->elem_segment_dropped_", GetGlobalName(seg->name),
+                " = true;", Newline());
+        }
+      } break;
+
+      case ExprType::TableCopy: {
+        const auto inst = cast<TableCopyExpr>(&expr);
+        Table* dest_table =
+            module_->tables[module_->GetTableIndex(inst->dst_table)];
+        const Table* src_table = module_->GetTable(inst->src_table);
+        Write("table_copy(", ExternalInstancePtr(dest_table->name), ", ",
+              ExternalInstancePtr(src_table->name), ", ", StackVar(2), ", ",
+              StackVar(1), ", ", StackVar(0), ");", Newline());
+      } break;
+
       case ExprType::TableGet:
       case ExprType::TableSet:
       case ExprType::TableGrow:
@@ -3180,10 +3344,10 @@ void CWriter::WriteCSource() {
   WriteTagTypes();
   WriteTags();
   WriteFuncDeclarations();
-  WriteFuncs();
   WriteGlobalInitializers();
   WriteDataInitializers();
   WriteElemInitializers();
+  WriteFuncs();
   WriteExports(WriteExportsKind::Definitions);
   WriteInitInstanceImport();
   WriteInit();
diff --git a/src/template/wasm2c.declarations.c b/src/template/wasm2c.declarations.c
index 4459790f7..8e1e1d3cb 100644
--- a/src/template/wasm2c.declarations.c
+++ b/src/template/wasm2c.declarations.c
@@ -444,4 +444,85 @@ static float wasm_sqrtf(float x) {
   return sqrtf(x);
 }
 
+static inline void memory_fill(wasm_rt_memory_t* mem, u32 d, u32 val, u32 n) {
+  RANGE_CHECK(mem, d, n);
+  memset(mem->data + d, val, n);
+}
+
+static inline void memory_copy(wasm_rt_memory_t* dest,
+                               const wasm_rt_memory_t* src,
+                               u32 dest_addr,
+                               u32 src_addr,
+                               u32 n) {
+  RANGE_CHECK(dest, dest_addr, n);
+  RANGE_CHECK(src, src_addr, n);
+  memmove(dest->data + dest_addr, src->data + src_addr, n);
+}
+
+static inline void memory_init(wasm_rt_memory_t* dest,
+                               const u8* src,
+                               u32 src_size,
+                               u32 dest_addr,
+                               u32 src_addr,
+                               u32 n) {
+  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
+    TRAP(OOB);
+  LOAD_DATA((*dest), dest_addr, src + src_addr, n);
+}
+
+typedef struct {
+  uint32_t func_type_index;
+  wasm_rt_funcref_t func;
+  size_t module_offset;
+} wasm_elem_segment_expr_t;
+
+static inline void table_init(wasm_rt_table_t* dest,
+                              const wasm_elem_segment_expr_t* src,
+                              u32 src_size,
+                              u32 dest_addr,
+                              u32 src_addr,
+                              u32 n,
+                              void* module_instance,
+                              const u32* func_types) {
+  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
+    TRAP(OOB);
+  if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))
+    TRAP(OOB);
+  for (u32 i = 0; i < n; i++) {
+    const wasm_elem_segment_expr_t* src_expr = &src[src_addr + i];
+    dest->data[dest_addr + i] =
+        (wasm_rt_elem_t){func_types[src_expr->func_type_index], src_expr->func,
+                         (char*)module_instance + src_expr->module_offset};
+  }
+}
+
+static inline void table_copy(wasm_rt_table_t* dest,
+                              const wasm_rt_table_t* src,
+                              u32 dest_addr,
+                              u32 src_addr,
+                              u32 n) {
+  if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))
+    TRAP(OOB);
+  if (UNLIKELY(src_addr + (uint64_t)n > src->size))
+    TRAP(OOB);
+
+  if (n == 0) {
+    return;
+  }
+
+  if (dest->data + dest_addr == src->data + src_addr) {
+    return;
+  }
+
+  if (dest->data + dest_addr < src->data + src_addr) {
+    for (u32 i = 0; i < n; i++) {
+      dest->data[dest_addr + i] = src->data[src_addr + i];
+    }
+  } else {
+    for (u32 i = n; i > 0; i--) {
+      dest->data[dest_addr + i - 1] = src->data[src_addr + i - 1];
+    }
+  }
+}
+
 static bool s_module_initialized = false;
diff --git a/src/template/wasm2c.includes.c b/src/template/wasm2c.includes.c
index 59def29c8..d89a94752 100644
--- a/src/template/wasm2c.includes.c
+++ b/src/template/wasm2c.includes.c
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <math.h>
+#include <stddef.h>
 #include <string.h>
 #if defined(_MSC_VER)
 #include <intrin.h>
diff --git a/src/tools/wasm2c.cc b/src/tools/wasm2c.cc
index 7ed745f49..3dd144834 100644
--- a/src/tools/wasm2c.cc
+++ b/src/tools/wasm2c.cc
@@ -109,7 +109,6 @@ static void ParseOptions(int argc, char** argv) {
             "wasm2c currently only supports a limited set of features.\n");
     exit(1);
   }
-  s_features.disable_bulk_memory();
 }
 
 // TODO(binji): copied from binary-writer-spec.cc, probably should share.
diff --git a/wasm2c/examples/fac/fac.c b/wasm2c/examples/fac/fac.c
index 303790f24..6233cf988 100644
--- a/wasm2c/examples/fac/fac.c
+++ b/wasm2c/examples/fac/fac.c
@@ -1,6 +1,7 @@
 /* Automatically generated by wasm2c */
 #include <assert.h>
 #include <math.h>
+#include <stddef.h>
 #include <string.h>
 #if defined(_MSC_VER)
 #include <intrin.h>
@@ -456,9 +457,91 @@ static float wasm_sqrtf(float x) {
   return sqrtf(x);
 }
 
+static inline void memory_fill(wasm_rt_memory_t* mem, u32 d, u32 val, u32 n) {
+  RANGE_CHECK(mem, d, n);
+  memset(mem->data + d, val, n);
+}
+
+static inline void memory_copy(wasm_rt_memory_t* dest,
+                               const wasm_rt_memory_t* src,
+                               u32 dest_addr,
+                               u32 src_addr,
+                               u32 n) {
+  RANGE_CHECK(dest, dest_addr, n);
+  RANGE_CHECK(src, src_addr, n);
+  memmove(dest->data + dest_addr, src->data + src_addr, n);
+}
+
+static inline void memory_init(wasm_rt_memory_t* dest,
+                               const u8* src,
+                               u32 src_size,
+                               u32 dest_addr,
+                               u32 src_addr,
+                               u32 n) {
+  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
+    TRAP(OOB);
+  LOAD_DATA((*dest), dest_addr, src + src_addr, n);
+}
+
+typedef struct {
+  uint32_t func_type_index;
+  wasm_rt_funcref_t func;
+  size_t module_offset;
+} wasm_elem_segment_expr_t;
+
+static inline void table_init(wasm_rt_table_t* dest,
+                              const wasm_elem_segment_expr_t* src,
+                              u32 src_size,
+                              u32 dest_addr,
+                              u32 src_addr,
+                              u32 n,
+                              void* module_instance,
+                              const u32* func_types) {
+  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
+    TRAP(OOB);
+  if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))
+    TRAP(OOB);
+  for (u32 i = 0; i < n; i++) {
+    const wasm_elem_segment_expr_t* src_expr = &src[src_addr + i];
+    dest->data[dest_addr + i] =
+        (wasm_rt_elem_t){func_types[src_expr->func_type_index], src_expr->func,
+                         (char*)module_instance + src_expr->module_offset};
+  }
+}
+
+static inline void table_copy(wasm_rt_table_t* dest,
+                              const wasm_rt_table_t* src,
+                              u32 dest_addr,
+                              u32 src_addr,
+                              u32 n) {
+  if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))
+    TRAP(OOB);
+  if (UNLIKELY(src_addr + (uint64_t)n > src->size))
+    TRAP(OOB);
+
+  if (n == 0) {
+    return;
+  }
+
+  if (dest->data + dest_addr == src->data + src_addr) {
+    return;
+  }
+
+  if (dest->data + dest_addr < src->data + src_addr) {
+    for (u32 i = 0; i < n; i++) {
+      dest->data[dest_addr + i] = src->data[src_addr + i];
+    }
+  } else {
+    for (u32 i = n; i > 0; i--) {
+      dest->data[dest_addr + i - 1] = src->data[src_addr + i - 1];
+    }
+  }
+}
+
 static bool s_module_initialized = false;
 
 static u32 func_types[1];
+
 static void init_func_types(void) {
   func_types[0] = wasm_rt_register_func_type(1, 1, WASM_RT_I32, WASM_RT_I32);
 }
@@ -468,6 +551,20 @@ static void init_tags(void) {
 
 static u32 w2c_fac(Z_fac_instance_t*, u32);
 
+static void init_globals(Z_fac_instance_t* instance) {
+}
+static void init_memory(Z_fac_instance_t* instance) {
+}
+
+static void init_data_instances(Z_fac_instance_t *instance) {
+}
+
+static void init_table(Z_fac_instance_t* instance) {
+}
+
+static void init_elem_instances(Z_fac_instance_t *instance) {
+}
+
 static u32 w2c_fac(Z_fac_instance_t* instance, u32 w2c_p0) {
   FUNC_PROLOGUE;
   u32 w2c_i0, w2c_i1, w2c_i2;
@@ -488,15 +585,6 @@ static u32 w2c_fac(Z_fac_instance_t* instance, u32 w2c_p0) {
   return w2c_i0;
 }
 
-static void init_globals(Z_fac_instance_t* instance) {
-}
-static void init_memory(Z_fac_instance_t* instance) {
-}
-
-static void init_table(Z_fac_instance_t* instance) {
-  uint32_t offset;
-}
-
 /* export: 'fac' */
 u32 Z_facZ_fac(Z_fac_instance_t* instance, u32 w2c_p0) {
   return w2c_fac(instance, w2c_p0);
@@ -515,6 +603,8 @@ void Z_fac_instantiate(Z_fac_instance_t* instance) {
   init_globals(instance);
   init_memory(instance);
   init_table(instance);
+  init_data_instances(instance);
+  init_elem_instances(instance);
 }
 
 void Z_fac_free(Z_fac_instance_t* instance) {
diff --git a/wasm2c/wasm-rt.h b/wasm2c/wasm-rt.h
index 7b8ec1f4a..c27905fc5 100644
--- a/wasm2c/wasm-rt.h
+++ b/wasm2c/wasm-rt.h
@@ -109,8 +109,8 @@ extern uint32_t wasm_rt_call_stack_depth;
 
 /** Reason a trap occurred. Provide this to `wasm_rt_trap`. */
 typedef enum {
-  WASM_RT_TRAP_NONE,         /** No error. */
-  WASM_RT_TRAP_OOB,          /** Out-of-bounds access in linear memory. */
+  WASM_RT_TRAP_NONE, /** No error. */
+  WASM_RT_TRAP_OOB,  /** Out-of-bounds access in linear memory or a table. */
   WASM_RT_TRAP_INT_OVERFLOW, /** Integer overflow on divide or truncation. */
   WASM_RT_TRAP_DIV_BY_ZERO,  /** Integer divide by zero. */
   WASM_RT_TRAP_INVALID_CONVERSION, /** Conversion from NaN to integer. */

From dee6c040175ed5f01292706ae712d23340a34894 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Tue, 29 Mar 2022 18:15:57 -0700
Subject: [PATCH 4/9] Add multi-memory load and store tests

---
 test/wasm2c/spec/multi-memory/load.txt  | 6 ++++++
 test/wasm2c/spec/multi-memory/store.txt | 6 ++++++
 2 files changed, 12 insertions(+)
 create mode 100644 test/wasm2c/spec/multi-memory/load.txt
 create mode 100644 test/wasm2c/spec/multi-memory/store.txt

diff --git a/test/wasm2c/spec/multi-memory/load.txt b/test/wasm2c/spec/multi-memory/load.txt
new file mode 100644
index 000000000..7618e6b07
--- /dev/null
+++ b/test/wasm2c/spec/multi-memory/load.txt
@@ -0,0 +1,6 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/proposals/multi-memory/load.wast
+;;; ARGS*: --enable-multi-memory
+(;; STDOUT ;;;
+54/54 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/multi-memory/store.txt b/test/wasm2c/spec/multi-memory/store.txt
new file mode 100644
index 000000000..a0af00422
--- /dev/null
+++ b/test/wasm2c/spec/multi-memory/store.txt
@@ -0,0 +1,6 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/proposals/multi-memory/store.wast
+;;; ARGS*: --enable-multi-memory
+(;; STDOUT ;;;
+35/35 tests passed.
+;;; STDOUT ;;)

From 3c158dbf147648b2afd9da9b99bf3c8d4374a3e7 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Thu, 31 Mar 2022 00:51:18 -0700
Subject: [PATCH 5/9] Restore current version of elem.wast test

---
 test/wasm2c/old-spec/elem.txt | 447 ----------------------------------
 test/wasm2c/spec/elem.txt     |   5 +
 2 files changed, 5 insertions(+), 447 deletions(-)
 delete mode 100644 test/wasm2c/old-spec/elem.txt
 create mode 100644 test/wasm2c/spec/elem.txt

diff --git a/test/wasm2c/old-spec/elem.txt b/test/wasm2c/old-spec/elem.txt
deleted file mode 100644
index 982f07479..000000000
--- a/test/wasm2c/old-spec/elem.txt
+++ /dev/null
@@ -1,447 +0,0 @@
-;;; TOOL: run-spec-wasm2c
-;;; ARGS*: --disable-bulk-memory --disable-reference-types
-;; Test the element section
-
-;; Syntax
-(module
-  (table $t 10 funcref)
-  (func $f)
-  (elem (i32.const 0))
-  (elem (i32.const 0) $f $f)
-  (elem (offset (i32.const 0)))
-  (elem (offset (i32.const 0)) $f $f)
-  (elem 0 (i32.const 0))
-  (elem 0x0 (i32.const 0) $f $f)
-  (elem 0x000 (offset (i32.const 0)))
-  (elem 0 (offset (i32.const 0)) $f $f)
-  (elem $t (i32.const 0))
-  (elem $t (i32.const 0) $f $f)
-  (elem $t (offset (i32.const 0)))
-  (elem $t (offset (i32.const 0)) $f $f)
-)
-
-;; Basic use
-
-(module
-  (table 10 funcref)
-  (func $f)
-  (elem (i32.const 0) $f)
-)
-(module
-  (import "spectest" "table" (table 10 funcref))
-  (func $f)
-  (elem (i32.const 0) $f)
-)
-
-(module
-  (table 10 funcref)
-  (func $f)
-  (elem (i32.const 0) $f)
-  (elem (i32.const 3) $f)
-  (elem (i32.const 7) $f)
-  (elem (i32.const 5) $f)
-  (elem (i32.const 3) $f)
-)
-(module
-  (import "spectest" "table" (table 10 funcref))
-  (func $f)
-  (elem (i32.const 9) $f)
-  (elem (i32.const 3) $f)
-  (elem (i32.const 7) $f)
-  (elem (i32.const 3) $f)
-  (elem (i32.const 5) $f)
-)
-
-(module
-  (global (import "spectest" "global_i32") i32)
-  (table 1000 funcref)
-  (func $f)
-  (elem (global.get 0) $f)
-)
-
-(module
-  (global $g (import "spectest" "global_i32") i32)
-  (table 1000 funcref)
-  (func $f)
-  (elem (global.get $g) $f)
-)
-
-(module
-  (type $out-i32 (func (result i32)))
-  (table 10 funcref)
-  (elem (i32.const 7) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-7") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 7))
-  )
-  (func (export "call-9") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
-  )
-)
-(assert_return (invoke "call-7") (i32.const 65))
-(assert_return (invoke "call-9") (i32.const 66))
-
-;; Corner cases
-
-(module
-  (table 10 funcref)
-  (func $f)
-  (elem (i32.const 9) $f)
-)
-(module
-  (import "spectest" "table" (table 10 funcref))
-  (func $f)
-  (elem (i32.const 9) $f)
-)
-
-(module
-  (table 0 funcref)
-  (elem (i32.const 0))
-)
-(module
-  (import "spectest" "table" (table 0 funcref))
-  (elem (i32.const 0))
-)
-
-(module
-  (table 0 0 funcref)
-  (elem (i32.const 0))
-)
-
-(module
-  (table 20 funcref)
-  (elem (i32.const 20))
-)
-
-(module
-  (import "spectest" "table" (table 0 funcref))
-  (func $f)
-  (elem (i32.const 0) $f)
-)
-
-(module
-  (import "spectest" "table" (table 0 100 funcref))
-  (func $f)
-  (elem (i32.const 0) $f)
-)
-
-(module
-  (import "spectest" "table" (table 0 funcref))
-  (func $f)
-  (elem (i32.const 1) $f)
-)
-
-(module
-  (import "spectest" "table" (table 0 30 funcref))
-  (func $f)
-  (elem (i32.const 1) $f)
-)
-
-;; Invalid bounds for elements
-
-(assert_unlinkable
-  (module
-    (table 0 funcref)
-    (func $f)
-    (elem (i32.const 0) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 0 0 funcref)
-    (func $f)
-    (elem (i32.const 0) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 0 1 funcref)
-    (func $f)
-    (elem (i32.const 0) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 0 funcref)
-    (elem (i32.const 1))
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 funcref)
-    (func $f)
-    (elem (i32.const 10) $f)
-  )
-  "elements segment does not fit"
-)
-(assert_unlinkable
-  (module
-    (import "spectest" "table" (table 10 funcref))
-    (func $f)
-    (elem (i32.const 10) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 20 funcref)
-    (func $f)
-    (elem (i32.const 10) $f)
-  )
-  "elements segment does not fit"
-)
-(assert_unlinkable
-  (module
-    (import "spectest" "table" (table 10 funcref))
-    (func $f)
-    (elem (i32.const 10) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 funcref)
-    (func $f)
-    (elem (i32.const -1) $f)
-  )
-  "elements segment does not fit"
-)
-(assert_unlinkable
-  (module
-    (import "spectest" "table" (table 10 funcref))
-    (func $f)
-    (elem (i32.const -1) $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 funcref)
-    (func $f)
-    (elem (i32.const -10) $f)
-  )
-  "elements segment does not fit"
-)
-(assert_unlinkable
-  (module
-    (import "spectest" "table" (table 10 funcref))
-    (func $f)
-    (elem (i32.const -10) $f)
-  )
-  "elements segment does not fit"
-)
-
-;; Element without table
-
-(assert_invalid
-  (module
-    (func $f)
-    (elem (i32.const 0) $f)
-  )
-  "unknown table"
-)
-
-;; Invalid offsets
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (i64.const 0))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module 
-    (table 1 funcref)
-    (elem (offset (;empty instruction sequence;)))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (offset (i32.const 0) (i32.const 0)))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (global (import "test" "global-i32") i32)
-    (table 1 funcref)
-    (elem (offset (global.get 0) (global.get 0)))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (global (import "test" "global-i32") i32)
-    (table 1 funcref)
-    (elem (offset (global.get 0) (i32.const 0)))
-  )
-  "type mismatch"
-)
-
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (i32.ctz (i32.const 0)))
-  )
-  "constant expression required"
-)
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (nop))
-  )
-  "constant expression required"
-)
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (offset (nop) (i32.const 0)))
-  )
-  "constant expression required"
-)
-
-(assert_invalid
-  (module
-    (table 1 funcref)
-    (elem (offset (i32.const 0) (nop)))
-  )
-  "constant expression required"
-)
-
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
-;;   "constant expression required"
-;; )
-
-(assert_invalid
-   (module 
-     (table 1 funcref)
-     (elem (global.get 0))
-   )
-   "unknown global 0"
-)
-
-(assert_invalid
-   (module
-     (global (import "test" "global-i32") i32)
-     (table 1 funcref)
-     (elem (global.get 1))
-   )
-   "unknown global 1"
-)
-
-(assert_invalid
-   (module 
-     (global (import "test" "global-mut-i32") (mut i32))
-     (table 1 funcref)
-     (elem (global.get 0))
-   )
-   "constant expression required"
-)
-
-;; Two elements target the same slot
-
-(module
-  (type $out-i32 (func (result i32)))
-  (table 10 funcref)
-  (elem (i32.const 9) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-overwritten") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
-  )
-)
-(assert_return (invoke "call-overwritten") (i32.const 66))
-
-(module
-  (type $out-i32 (func (result i32)))
-  (import "spectest" "table" (table 10 funcref))
-  (elem (i32.const 9) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-overwritten-element") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
-  )
-)
-(assert_return (invoke "call-overwritten-element") (i32.const 66))
-
-;; Element sections across multiple modules change the same table
-
-(module $module1
-  (type $out-i32 (func (result i32)))
-  (table (export "shared-table") 10 funcref)
-  (elem (i32.const 8) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-7") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 7))
-  )
-  (func (export "call-8") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 8))
-  )
-  (func (export "call-9") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
-  )
-)
-
-(register "module1" $module1)
-
-(assert_trap (invoke $module1 "call-7") "uninitialized element")
-(assert_return (invoke $module1 "call-8") (i32.const 65))
-(assert_return (invoke $module1 "call-9") (i32.const 66))
-
-(module $module2
-  (type $out-i32 (func (result i32)))
-  (import "module1" "shared-table" (table 10 funcref))
-  (elem (i32.const 7) $const-i32-c)
-  (elem (i32.const 8) $const-i32-d)
-  (func $const-i32-c (type $out-i32) (i32.const 67))
-  (func $const-i32-d (type $out-i32) (i32.const 68))
-)
-
-(assert_return (invoke $module1 "call-7") (i32.const 67))
-(assert_return (invoke $module1 "call-8") (i32.const 68))
-(assert_return (invoke $module1 "call-9") (i32.const 66))
-
-(module $module3
-  (type $out-i32 (func (result i32)))
-  (import "module1" "shared-table" (table 10 funcref))
-  (elem (i32.const 8) $const-i32-e)
-  (elem (i32.const 9) $const-i32-f)
-  (func $const-i32-e (type $out-i32) (i32.const 69))
-  (func $const-i32-f (type $out-i32) (i32.const 70))
-)
-
-(assert_return (invoke $module1 "call-7") (i32.const 67))
-(assert_return (invoke $module1 "call-8") (i32.const 69))
-(assert_return (invoke $module1 "call-9") (i32.const 70))
-(;; STDOUT ;;;
-13/13 tests passed.
-;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/elem.txt b/test/wasm2c/spec/elem.txt
new file mode 100644
index 000000000..498990d35
--- /dev/null
+++ b/test/wasm2c/spec/elem.txt
@@ -0,0 +1,5 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/elem.wast
+(;; STDOUT ;;;
+27/27 tests passed.
+;;; STDOUT ;;)

From f95f8a0b1ec212b052a3ba72a36589f9a0fa839e Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Thu, 31 Mar 2022 01:33:38 -0700
Subject: [PATCH 6/9] Add bulk-memory tests

---
 .../bulk-memory-operations/imports.txt        |  607 ++++++
 .../bulk-memory-operations/linking.txt        |  399 ++++
 .../bulk-memory-operations/table_copy.txt     | 1599 +++++++++++++++
 .../bulk-memory-operations/table_init.txt     | 1780 +++++++++++++++++
 test/wasm2c/spec/bulk.txt                     |    5 +
 test/wasm2c/spec/memory_copy.txt              |    5 +
 test/wasm2c/spec/memory_fill.txt              |    5 +
 test/wasm2c/spec/memory_init.txt              |    5 +
 8 files changed, 4405 insertions(+)
 create mode 100644 test/wasm2c/old-spec/bulk-memory-operations/imports.txt
 create mode 100644 test/wasm2c/old-spec/bulk-memory-operations/linking.txt
 create mode 100644 test/wasm2c/old-spec/bulk-memory-operations/table_copy.txt
 create mode 100644 test/wasm2c/old-spec/bulk-memory-operations/table_init.txt
 create mode 100644 test/wasm2c/spec/bulk.txt
 create mode 100644 test/wasm2c/spec/memory_copy.txt
 create mode 100644 test/wasm2c/spec/memory_fill.txt
 create mode 100644 test/wasm2c/spec/memory_init.txt

diff --git a/test/wasm2c/old-spec/bulk-memory-operations/imports.txt b/test/wasm2c/old-spec/bulk-memory-operations/imports.txt
new file mode 100644
index 000000000..3084f0597
--- /dev/null
+++ b/test/wasm2c/old-spec/bulk-memory-operations/imports.txt
@@ -0,0 +1,607 @@
+;;; TOOL: run-spec-wasm2c
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (table (export "table-10-inf") 10 funcref)
+  ;; (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    ;; JavaScript can't handle i64 yet.
+    ;; (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    ;; JavaScript can't handle i64 yet.
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table 10 20 funcref))
+  (elem (table 0) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table (import "spectest" "table") 10 20 funcref)
+  (elem (table 0) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(assert_invalid
+  (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref)))
+  "multiple tables"
+)
+(assert_invalid
+  (module (import "" "" (table 10 funcref)) (table 10 funcref))
+  "multiple tables"
+)
+(assert_invalid
+  (module (table 10 funcref) (table 10 funcref))
+  "multiple tables"
+)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
+(;; STDOUT ;;;
+spectest.print_i32(13)
+spectest.print_i32_f32(14 42)
+spectest.print_i32(13)
+spectest.print_i32(13)
+spectest.print_f32(13)
+spectest.print_i32(13)
+spectest.print_f64_f64(25 53)
+spectest.print_f64(24)
+spectest.print_f64(24)
+spectest.print_f64(24)
+29/29 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/old-spec/bulk-memory-operations/linking.txt b/test/wasm2c/old-spec/bulk-memory-operations/linking.txt
new file mode 100644
index 000000000..d2a8bc755
--- /dev/null
+++ b/test/wasm2c/old-spec/bulk-memory-operations/linking.txt
@@ -0,0 +1,399 @@
+;;; TOOL: run-spec-wasm2c
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (global.get $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (global.get $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 funcref)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table funcref (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (local.get 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 funcref)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
+
+(module
+  (table (import "Mt" "tab") 0 funcref)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (global.get 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 0 funcref)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "out of bounds"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+;; Unlike in the v1 spec, the elements stored before an out-of-bounds access
+;; persist after the instantiation failure.
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 8) $f $f $f $f $f)  ;; (partially) out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+(assert_trap (invoke $Mt "call" (i32.const 8)) "uninitialized")
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (memory 1)
+    (data (i32.const 0x10000) "d")  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "out of bounds"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+;; Unlike in v1 spec, bytes written before an out-of-bounds access persist
+;; after the instantiation failure.
+(assert_trap
+  (module
+    ;; Note: the memory is 5 pages large by the time we get here.
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 327670) "zzzzzzzzzzzzzzzzzz") ;; (partially) out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+(assert_return (invoke $Mm "load" (i32.const 327670)) (i32.const 0))
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 funcref)
+    (func)
+    (elem (i32.const 0) 0)  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+;; Store is modified if the start function traps.
+(module $Ms
+  (type $t (func (result i32)))
+  (memory (export "memory") 1)
+  (table (export "table") 1 funcref)
+  (func (export "get memory[0]") (type $t)
+    (i32.load8_u (i32.const 0))
+  )
+  (func (export "get table[0]") (type $t)
+    (call_indirect (type $t) (i32.const 0))
+  )
+)
+(register "Ms" $Ms)
+
+(assert_trap
+  (module
+    (import "Ms" "memory" (memory 1))
+    (import "Ms" "table" (table 1 funcref))
+    (data (i32.const 0) "hello")
+    (elem (i32.const 0) $f)
+    (func $f (result i32)
+      (i32.const 0xdead)
+    )
+    (func $main
+      (unreachable)
+    )
+    (start $main)
+  )
+  "unreachable"
+)
+
+(assert_return (invoke $Ms "get memory[0]") (i32.const 104))  ;; 'h'
+(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead))
+(;; STDOUT ;;;
+90/90 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/old-spec/bulk-memory-operations/table_copy.txt b/test/wasm2c/old-spec/bulk-memory-operations/table_copy.txt
new file mode 100644
index 000000000..ab5fd9147
--- /dev/null
+++ b/test/wasm2c/old-spec/bulk-memory-operations/table_copy.txt
@@ -0,0 +1,1599 @@
+;;; TOOL: run-spec-wasm2c
+;;
+;; Generated by ../meta/generate_table_copy.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 27)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 18)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 6))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 15) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 15) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 23)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 8))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 11)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 16)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 17)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 18)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 10))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 112)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 112)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 113)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 114)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 115)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 116)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 117)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 118)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 119)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 120)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 121)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 122)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 123)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 124)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 125)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 126)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 127)) (i32.const 15))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 15))
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(;; STDOUT ;;;
+802/802 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/old-spec/bulk-memory-operations/table_init.txt b/test/wasm2c/old-spec/bulk-memory-operations/table_init.txt
new file mode 100644
index 000000000..0c69a894d
--- /dev/null
+++ b/test/wasm2c/old-spec/bulk-memory-operations/table_init.txt
@@ -0,0 +1,1780 @@
+;;; TOOL: run-spec-wasm2c
+;;
+;; Generated by ../meta/generate_table_init.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (elem.drop 1)
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (elem.drop 3)
+    (table.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (table.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (table.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (table.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (table.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 21)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "check" (i32.const 24)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+(assert_invalid
+  (module
+    (func (export "test")
+      (elem.drop 0)))
+  "unknown elem segment 0")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (elem.drop 4)))
+  "unknown elem segment 4")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 2)
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))
+    (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (elem.drop 1)))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 2) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 2) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 24) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 25) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 96) (i32.const 32)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 97) (i32.const 31)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 64 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 48) (i32.const 4294967280)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 16 16 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 8) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+
+(module
+  (table 1 funcref)
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
+
+(;; STDOUT ;;;
+568/568 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/bulk.txt b/test/wasm2c/spec/bulk.txt
new file mode 100644
index 000000000..f5a3891b3
--- /dev/null
+++ b/test/wasm2c/spec/bulk.txt
@@ -0,0 +1,5 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/bulk.wast
+(;; STDOUT ;;;
+66/66 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/memory_copy.txt b/test/wasm2c/spec/memory_copy.txt
new file mode 100644
index 000000000..a585f5454
--- /dev/null
+++ b/test/wasm2c/spec/memory_copy.txt
@@ -0,0 +1,5 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/memory_copy.wast
+(;; STDOUT ;;;
+4338/4338 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/memory_fill.txt b/test/wasm2c/spec/memory_fill.txt
new file mode 100644
index 000000000..fb5998021
--- /dev/null
+++ b/test/wasm2c/spec/memory_fill.txt
@@ -0,0 +1,5 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/memory_fill.wast
+(;; STDOUT ;;;
+20/20 tests passed.
+;;; STDOUT ;;)
diff --git a/test/wasm2c/spec/memory_init.txt b/test/wasm2c/spec/memory_init.txt
new file mode 100644
index 000000000..cd79f1584
--- /dev/null
+++ b/test/wasm2c/spec/memory_init.txt
@@ -0,0 +1,5 @@
+;;; TOOL: run-spec-wasm2c
+;;; STDIN_FILE: third_party/testsuite/memory_init.wast
+(;; STDOUT ;;;
+140/140 tests passed.
+;;; STDOUT ;;)

From af0dfd6f45349b3caaa37d9673860e48dd00199f Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Wed, 27 Apr 2022 22:25:37 -0700
Subject: [PATCH 7/9] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7a1aa00ad..b616a2c30 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ Wabt has been compiled to JavaScript via emscripten. Some of the functionality i
 | [threads][]           | `--enable-threads`          |   | ✓ | ✓ | ✓ | ✓ |   |
 | [multi-value][]       | `--disable-multi-value`     | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
 | [tail-call][]         | `--enable-tail-call`        |   | ✓ | ✓ | ✓ | ✓ |   |
-| [bulk memory][]       | `--disable-bulk-memory`     | ✓ | ✓ | ✓ | ✓ | ✓ |   |
+| [bulk memory][]       | `--disable-bulk-memory`     | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
 | [reference types][]   | `--disable-reference-types` | ✓ | ✓ | ✓ | ✓ | ✓ |   |
 | [annotations][]       | `--enable-annotations`      |   |   | ✓ |   |   |   |
 | [memory64][]          | `--enable-memory64`         |   | ✓ | ✓ | ✓ | ✓ |   |

From a849c2c9792b2e578e09289cc299ef88c3b08b33 Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Tue, 20 Sep 2022 12:48:12 -0700
Subject: [PATCH 8/9] c-writer.cc: add newline after init_globals()

---
 src/c-writer.cc           | 2 +-
 wasm2c/examples/fac/fac.c | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/c-writer.cc b/src/c-writer.cc
index 56890ec89..2565d8165 100644
--- a/src/c-writer.cc
+++ b/src/c-writer.cc
@@ -1387,7 +1387,7 @@ void CWriter::WriteGlobalInitializers() {
     }
     ++global_index;
   }
-  Write(CloseBrace(), Newline());
+  Write(CloseBrace(), Newline(), Newline());
 }
 
 static inline bool is_droppable(const DataSegment* data_segment) {
diff --git a/wasm2c/examples/fac/fac.c b/wasm2c/examples/fac/fac.c
index 6233cf988..24d4e177c 100644
--- a/wasm2c/examples/fac/fac.c
+++ b/wasm2c/examples/fac/fac.c
@@ -553,6 +553,7 @@ static u32 w2c_fac(Z_fac_instance_t*, u32);
 
 static void init_globals(Z_fac_instance_t* instance) {
 }
+
 static void init_memory(Z_fac_instance_t* instance) {
 }
 

From b716f71ce86816a80cc5fdcce5e2a81341f4f2bd Mon Sep 17 00:00:00 2001
From: Keith Winstein <keithw@cs.stanford.edu>
Date: Tue, 20 Sep 2022 22:13:17 -0700
Subject: [PATCH 9/9] c-writer.cc: make conditional treatment of data segments
 consistent

---
 src/c-writer.cc | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/c-writer.cc b/src/c-writer.cc
index 2565d8165..1270b716b 100644
--- a/src/c-writer.cc
+++ b/src/c-writer.cc
@@ -1446,19 +1446,20 @@ void CWriter::WriteDataInitializers() {
     }
   }
   for (const DataSegment* data_segment : module_->data_segments) {
-    if (data_segment->kind == SegmentKind::Active) {
-      const Memory* memory =
-          module_->memories[module_->GetMemoryIndex(data_segment->memory_var)];
-      Write("LOAD_DATA(", ExternalInstanceRef(memory->name), ", ");
-      WriteInitExpr(data_segment->offset);
-      if (data_segment->data.empty()) {
-        Write(", NULL, 0");
-      } else {
-        Write(", data_segment_data_", GetGlobalName(data_segment->name), ", ",
-              data_segment->data.size());
-      }
-      Write(");", Newline());
+    if (data_segment->kind != SegmentKind::Active) {
+      continue;
     }
+    const Memory* memory =
+        module_->memories[module_->GetMemoryIndex(data_segment->memory_var)];
+    Write("LOAD_DATA(", ExternalInstanceRef(memory->name), ", ");
+    WriteInitExpr(data_segment->offset);
+    if (data_segment->data.empty()) {
+      Write(", NULL, 0");
+    } else {
+      Write(", data_segment_data_", GetGlobalName(data_segment->name), ", ",
+            data_segment->data.size());
+    }
+    Write(");", Newline());
   }
 
   Write(CloseBrace(), Newline());