[Parser] Parse tags and throw (#6126)

Also fix the parser to correctly error if an imported item appears after a
non-imported item and make the corresponding fix to the test.

11 files changed, 359 insertions, 183 deletions

diff --git a/src/parser/context-decls.cpp b/src/parser/context-decls.cpp
index 17b389488..721127614 100644
--- a/src/parser/context-decls.cpp
+++ b/src/parser/context-decls.cpp
@@ -69,9 +69,7 @@ Result<> ParseDeclsCtx::addFunc(Name name,
                                 TypeUseT type,
                                 std::optional<LocalsT>,
                                 Index pos) {
-  if (import && hasNonImport) {
-    return in.err(pos, "import after non-import");
-  }
+  CHECK_ERR(checkImport(pos, import));
   auto f = addFuncDecl(pos, name, import);
   CHECK_ERR(f);
   CHECK_ERR(addExports(in, wasm, *f, exports, ExternalKind::Function));
@@ -109,9 +107,7 @@ Result<> ParseDeclsCtx::addMemory(Name name,
                                   ImportNames* import,
                                   MemType type,
                                   Index pos) {
-  if (import && hasNonImport) {
-    return in.err(pos, "import after non-import");
-  }
+  CHECK_ERR(checkImport(pos, import));
   auto m = addMemoryDecl(pos, name, import, type);
   CHECK_ERR(m);
   CHECK_ERR(addExports(in, wasm, *m, exports, ExternalKind::Memory));
@@ -156,9 +152,7 @@ Result<> ParseDeclsCtx::addGlobal(Name name,
                                   GlobalTypeT,
                                   std::optional<ExprT>,
                                   Index pos) {
-  if (import && hasNonImport) {
-    return in.err(pos, "import after non-import");
-  }
+  CHECK_ERR(checkImport(pos, import));
   auto g = addGlobalDecl(pos, name, import);
   CHECK_ERR(g);
   CHECK_ERR(addExports(in, wasm, *g, exports, ExternalKind::Global));
@@ -190,4 +184,36 @@ Result<> ParseDeclsCtx::addData(Name name,
   return Ok{};
 }
 
+Result<Tag*>
+ParseDeclsCtx::addTagDecl(Index pos, Name name, ImportNames* importNames) {
+  auto t = std::make_unique<Tag>();
+  if (name) {
+    if (wasm.getTagOrNull(name)) {
+      // TODO: if the existing tag is not explicitly named, fix its name and
+      // continue.
+      return in.err(pos, "repeated tag name");
+    }
+    t->setExplicitName(name);
+  } else {
+    name = (importNames ? "timport$" : "") + std::to_string(tagCounter++);
+    name = Names::getValidTagName(wasm, name);
+    t->name = name;
+  }
+  applyImportNames(*t, importNames);
+  return wasm.addTag(std::move(t));
+}
+
+Result<> ParseDeclsCtx::addTag(Name name,
+                               const std::vector<Name>& exports,
+                               ImportNames* import,
+                               TypeUseT type,
+                               Index pos) {
+  CHECK_ERR(checkImport(pos, import));
+  auto t = addTagDecl(pos, name, import);
+  CHECK_ERR(t);
+  CHECK_ERR(addExports(in, wasm, *t, exports, ExternalKind::Tag));
+  tagDefs.push_back({name, pos, Index(tagDefs.size())});
+  return Ok{};
+}
+
 } // namespace wasm::WATParser
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 192442c84..ed4d1283c 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -286,6 +286,7 @@ struct NullInstrParserCtx {
   using MemoryIdxT = Ok;
   using DataIdxT = Ok;
   using LabelIdxT = Ok;
+  using TagIdxT = Ok;
 
   using MemargT = Ok;
 
@@ -309,6 +310,8 @@ struct NullInstrParserCtx {
   DataIdxT getDataFromName(Name) { return Ok{}; }
   LabelIdxT getLabelFromIdx(uint32_t) { return Ok{}; }
   LabelIdxT getLabelFromName(Name) { return Ok{}; }
+  TagIdxT getTagFromIdx(uint32_t) { return Ok{}; }
+  TagIdxT getTagFromName(Name) { return Ok{}; }
 
   MemargT getMemarg(uint64_t, uint32_t) { return Ok{}; }
 
@@ -393,6 +396,7 @@ struct NullInstrParserCtx {
   Result<> makeRefIsNull(Index) { return Ok{}; }
   Result<> makeRefFunc(Index, FuncIdxT) { return Ok{}; }
   Result<> makeRefEq(Index) { return Ok{}; }
+  Result<> makeThrow(Index, TagIdxT) { return Ok{}; }
   template<typename HeapTypeT> Result<> makeCallRef(Index, HeapTypeT, bool) {
     return Ok{};
   }
@@ -480,6 +484,7 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
   std::vector<DefPos> memoryDefs;
   std::vector<DefPos> globalDefs;
   std::vector<DefPos> dataDefs;
+  std::vector<DefPos> tagDefs;
 
   // Positions of typeuses that might implicitly define new types.
   std::vector<Index> implicitTypeDefs;
@@ -489,10 +494,22 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
   int memoryCounter = 0;
   int globalCounter = 0;
   int dataCounter = 0;
+  int tagCounter = 0;
 
   // Used to verify that all imports come before all non-imports.
   bool hasNonImport = false;
 
+  Result<> checkImport(Index pos, ImportNames* import) {
+    if (import) {
+      if (hasNonImport) {
+        return in.err(pos, "import after non-import");
+      }
+    } else {
+      hasNonImport = true;
+    }
+    return Ok{};
+  }
+
   ParseDeclsCtx(std::string_view in, Module& wasm) : in(in), wasm(wasm) {}
 
   void addFuncType(SignatureT) {}
@@ -568,6 +585,14 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
                    std::optional<ExprT>,
                    std::vector<char>&& data,
                    Index pos);
+
+  Result<Tag*> addTagDecl(Index pos, Name name, ImportNames* importNames);
+
+  Result<> addTag(Name name,
+                  const std::vector<Name>& exports,
+                  ImportNames* import,
+                  TypeUseT type,
+                  Index pos);
 };
 
 // Phase 2: Parse type definitions into a TypeBuilder.
@@ -814,6 +839,16 @@ struct ParseModuleTypesCtx : TypeParserCtx<ParseModuleTypesCtx>,
     g->type = type.type;
     return Ok{};
   }
+
+  Result<>
+  addTag(Name, const std::vector<Name>&, ImportNames*, TypeUse use, Index pos) {
+    auto& t = wasm.tags[index];
+    if (!use.type.isSignature()) {
+      return in.err(pos, "tag type must be a signature");
+    }
+    t->sig = use.type.getSignature();
+    return Ok{};
+  }
 };
 
 // Phase 5: Parse module element definitions, including instructions.
@@ -830,6 +865,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
   using GlobalIdxT = Name;
   using MemoryIdxT = Name;
   using DataIdxT = Name;
+  using TagIdxT = Name;
 
   using MemargT = Memarg;
 
@@ -990,6 +1026,20 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return irBuilder.getLabelIndex(name);
   }
 
+  Result<Name> getTagFromIdx(uint32_t idx) {
+    if (idx >= wasm.tags.size()) {
+      return in.err("tag index out of bounds");
+    }
+    return wasm.tags[idx]->name;
+  }
+
+  Result<Name> getTagFromName(Name name) {
+    if (!wasm.getTagOrNull(name)) {
+      return in.err("tag $" + name.toString() + " does not exist");
+    }
+    return name;
+  }
+
   Result<TypeUseT> makeTypeUse(Index pos,
                                std::optional<HeapTypeT> type,
                                ParamsT* params,
@@ -1009,6 +1059,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
                      Index);
   Result<>
   addData(Name, Name* mem, std::optional<ExprT> offset, DataStringT, Index pos);
+
   Result<Index> addScratchLocal(Index pos, Type type) {
     if (!func) {
       return in.err(pos,
@@ -1288,6 +1339,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
 
   Result<> makeRefEq(Index pos) { return withLoc(pos, irBuilder.makeRefEq()); }
 
+  Result<> makeThrow(Index pos, Name tag) {
+    return withLoc(pos, irBuilder.makeThrow(tag));
+  }
+
   Result<> makeCallRef(Index pos, HeapType type, bool isReturn) {
     return withLoc(pos, irBuilder.makeCallRef(type, isReturn));
   }
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 41e625657..9201314dc 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -174,6 +174,7 @@ template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemuse(Ctx&);
 template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::LocalIdxT> localidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::LabelIdxT> labelidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::TagIdxT> tagidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::TypeUseT> typeuse(Ctx&);
 MaybeResult<ImportNames> inlineImport(ParseInput&);
 Result<std::vector<Name>> inlineExports(ParseInput&);
@@ -186,6 +187,7 @@ template<typename Ctx> MaybeResult<> memory(Ctx&);
 template<typename Ctx> MaybeResult<> global(Ctx&);
 template<typename Ctx> Result<typename Ctx::DataStringT> datastring(Ctx&);
 template<typename Ctx> MaybeResult<> data(Ctx&);
+template<typename Ctx> MaybeResult<> tag(Ctx&);
 template<typename Ctx> MaybeResult<> modulefield(Ctx&);
 template<typename Ctx> Result<> module(Ctx&);
 
@@ -1274,7 +1276,9 @@ Result<> makeTryOrCatchBody(Ctx& ctx, Index pos, Type type, bool isTry) {
 }
 
 template<typename Ctx> Result<> makeThrow(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto tag = tagidx(ctx);
+  CHECK_ERR(tag);
+  return ctx.makeThrow(pos, *tag);
 }
 
 template<typename Ctx> Result<> makeRethrow(Ctx& ctx, Index pos) {
@@ -1627,6 +1631,18 @@ template<typename Ctx> Result<typename Ctx::LabelIdxT> labelidx(Ctx& ctx) {
   return ctx.in.err("expected label index or identifier");
 }
 
+// tagidx ::= x:u32 => x
+//          | v:id => x (if tags[x] = v)
+template<typename Ctx> Result<typename Ctx::TagIdxT> tagidx(Ctx& ctx) {
+  if (auto x = ctx.in.takeU32()) {
+    return ctx.getTagFromIdx(*x);
+  }
+  if (auto id = ctx.in.takeID()) {
+    return ctx.getTagFromName(*id);
+  }
+  return ctx.in.err("expected tag index or identifier");
+}
+
 // typeuse ::= '(' 'type' x:typeidx ')'                                => x, []
 //                 (if typedefs[x] = [t1*] -> [t2*]
 //           | '(' 'type' x:typeidx ')' ((t1,IDs):param)* (t2:result)* => x, IDs
@@ -2011,6 +2027,36 @@ template<typename Ctx> MaybeResult<> data(Ctx& ctx) {
   return Ok{};
 }
 
+// tag ::= '(' 'tag' id? ('(' 'export' name ')')*
+//            ('(' 'import' mod:name nm:name ')')? typeuse ')'
+template<typename Ctx> MaybeResult<> tag(Ctx& ctx) {
+  auto pos = ctx.in.getPos();
+  if (!ctx.in.takeSExprStart("tag"sv)) {
+    return {};
+  }
+
+  Name name;
+  if (auto id = ctx.in.takeID()) {
+    name = *id;
+  }
+
+  auto exports = inlineExports(ctx.in);
+  CHECK_ERR(exports);
+
+  auto import = inlineImport(ctx.in);
+  CHECK_ERR(import);
+
+  auto type = typeuse(ctx);
+  CHECK_ERR(type);
+
+  if (!ctx.in.takeRParen()) {
+    return ctx.in.err("expected end of tag");
+  }
+
+  CHECK_ERR(ctx.addTag(name, *exports, import.getPtr(), *type, pos));
+  return Ok{};
+}
+
 // modulefield ::= deftype
 //               | import
 //               | func
@@ -2021,6 +2067,7 @@ template<typename Ctx> MaybeResult<> data(Ctx& ctx) {
 //               | start
 //               | elem
 //               | data
+//               | tag
 template<typename Ctx> MaybeResult<> modulefield(Ctx& ctx) {
   if (auto t = ctx.in.peek(); !t || t->isRParen()) {
     return {};
@@ -2045,6 +2092,10 @@ template<typename Ctx> MaybeResult<> modulefield(Ctx& ctx) {
     CHECK_ERR(res);
     return Ok{};
   }
+  if (auto res = tag(ctx)) {
+    CHECK_ERR(res);
+    return Ok{};
+  }
   return ctx.in.err("unrecognized module field");
 }
 
diff --git a/src/parser/wat-parser.cpp b/src/parser/wat-parser.cpp
index 7e106d3b9..be3bca5c8 100644
--- a/src/parser/wat-parser.cpp
+++ b/src/parser/wat-parser.cpp
@@ -146,6 +146,7 @@ Result<> parseModule(Module& wasm, std::string_view input) {
     CHECK_ERR(parseDefs(ctx, decls.funcDefs, func));
     CHECK_ERR(parseDefs(ctx, decls.memoryDefs, memory));
     CHECK_ERR(parseDefs(ctx, decls.globalDefs, global));
+    CHECK_ERR(parseDefs(ctx, decls.tagDefs, tag));
     // TODO: Parse types of other module elements.
   }
   {
diff --git a/src/parser/wat-parser.h b/src/parser/wat-parser.h
index d3ad8d7f3..b31523af9 100644
--- a/src/parser/wat-parser.h
+++ b/src/parser/wat-parser.h
@@ -29,4 +29,4 @@ Result<> parseModule(Module& wasm, std::string_view in);
 
 } // namespace wasm::WATParser
 
-#endif // paser_wat_parser_h
+#endif // parser_wat_parser_h
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 1dd7a7e09..2f379b4e1 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -849,7 +849,7 @@ public:
   Throw* makeThrow(Tag* tag, const std::vector<Expression*>& args) {
     return makeThrow(tag->name, args);
   }
-  Throw* makeThrow(Name tag, const std::vector<Expression*>& args) {
+  template<typename T> Throw* makeThrow(Name tag, const T& args) {
     auto* ret = wasm.allocator.alloc<Throw>();
     ret->tag = tag;
     ret->operands.set(args);
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 9b8ae043f..e7613b373 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -146,7 +146,7 @@ public:
   // [[nodiscard]] Result<> makeTableFill();
   // [[nodiscard]] Result<> makeTableCopy();
   // [[nodiscard]] Result<> makeTry();
-  // [[nodiscard]] Result<> makeThrow();
+  [[nodiscard]] Result<> makeThrow(Name tag);
   // [[nodiscard]] Result<> makeRethrow();
   // [[nodiscard]] Result<> makeTupleMake();
   // [[nodiscard]] Result<> makeTupleExtract();
@@ -203,6 +203,7 @@ public:
   [[nodiscard]] Result<> visitCall(Call*);
   [[nodiscard]] Result<> visitCallIndirect(CallIndirect*);
   [[nodiscard]] Result<> visitCallRef(CallRef*);
+  [[nodiscard]] Result<> visitThrow(Throw*);
 
 private:
   Module& wasm;
diff --git a/src/wasm/wasm-io.cpp b/src/wasm/wasm-io.cpp
index a340b4c23..37d28ca4b 100644
--- a/src/wasm/wasm-io.cpp
+++ b/src/wasm/wasm-io.cpp
@@ -25,12 +25,11 @@
 //
 
 #include "wasm-io.h"
+#include "parser/wat-parser.h"
 #include "support/debug.h"
 #include "support/path.h"
 #include "wasm-binary.h"
 #include "wasm-s-parser.h"
-#include "wat-parser.h"
-
 
 namespace wasm {
 
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index dfbf156b2..9bca1967b 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -445,6 +445,17 @@ Result<> IRBuilder::visitCallRef(CallRef* curr) {
   return Ok{};
 }
 
+Result<> IRBuilder::visitThrow(Throw* curr) {
+  auto numArgs = wasm.getTag(curr->tag)->sig.params.size();
+  curr->operands.resize(numArgs);
+  for (size_t i = 0; i < numArgs; ++i) {
+    auto arg = pop();
+    CHECK_ERR(arg);
+    curr->operands[numArgs - 1 - i] = *arg;
+  }
+  return Ok{};
+}
+
 Result<> IRBuilder::visitFunctionStart(Function* func) {
   if (!scopeStack.empty()) {
     return Err{"unexpected start of function"};
@@ -1005,7 +1016,13 @@ Result<> IRBuilder::makeRefEq() {
 
 // Result<> IRBuilder::makeTry() {}
 
-// Result<> IRBuilder::makeThrow() {}
+Result<> IRBuilder::makeThrow(Name tag) {
+  Throw curr(wasm.allocator);
+  curr.tag = tag;
+  CHECK_ERR(visitThrow(&curr));
+  push(builder.makeThrow(tag, curr.operands));
+  return Ok{};
+}
 
 // Result<> IRBuilder::makeRethrow() {}
 
diff --git a/src/wat-parser.h b/src/wat-parser.h
deleted file mode 100644
index bb31ed0b1..000000000
--- a/src/wat-parser.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2022 WebAssembly Community Group participants
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef wasm_wat_parser_h
-#define wasm_wat_parser_h
-
-#include <string_view>
-
-#include "support/result.h"
-#include "wasm.h"
-
-namespace wasm::WATParser {
-
-// Parse a single WAT module.
-Result<> parseModule(Module& wasm, std::string_view in);
-
-} // namespace wasm::WATParser
-
-#endif // wasm_wat_parser.h
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 6498a6e31..c61f502ca 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -15,9 +15,9 @@
  (rec
   ;; CHECK:      (type $pair (struct (field (mut i32)) (field (mut i64))))
 
-  ;; CHECK:      (type $4 (func (result i32 i64)))
+  ;; CHECK:      (type $4 (func (param i32 i64)))
 
-  ;; CHECK:      (type $5 (func (param i32 i64)))
+  ;; CHECK:      (type $5 (func (result i32 i64)))
 
   ;; CHECK:      (type $a1 (array i64))
 
@@ -27,13 +27,15 @@
 
   ;; CHECK:      (type $many (sub (func (param i32 i64 f32 f64) (result anyref (ref func)))))
 
-  ;; CHECK:      (type $a0 (array i32))
+  ;; CHECK:      (type $10 (func))
 
   ;; CHECK:      (type $11 (func (param i32)))
 
-  ;; CHECK:      (type $12 (func (param i32 i32 i32)))
+  ;; CHECK:      (type $a0 (array i32))
+
+  ;; CHECK:      (type $13 (func (param i32 i32 i32)))
 
-  ;; CHECK:      (type $13 (func (param v128 i32) (result v128)))
+  ;; CHECK:      (type $14 (func (param v128 i32) (result v128)))
 
   ;; CHECK:      (rec
   ;; CHECK-NEXT:  (type $s0 (struct ))
@@ -48,73 +50,73 @@
 
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
- ;; CHECK:      (type $18 (func (param i32 i64) (result f32)))
+ ;; CHECK:      (type $19 (func (param i32 i64) (result f32)))
 
- ;; CHECK:      (type $19 (func (param i32 i32)))
+ ;; CHECK:      (type $20 (func (param i32 i32)))
 
- ;; CHECK:      (type $20 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $21 (func (param i32 i32 f64 f64)))
 
- ;; CHECK:      (type $21 (func (param i64)))
+ ;; CHECK:      (type $22 (func (param i64)))
 
- ;; CHECK:      (type $22 (func (param v128) (result i32)))
+ ;; CHECK:      (type $23 (func (param v128) (result i32)))
 
- ;; CHECK:      (type $23 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $24 (func (param v128 v128) (result v128)))
 
- ;; CHECK:      (type $24 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $25 (func (param v128 v128 v128) (result v128)))
 
- ;; CHECK:      (type $25 (func (param i32 i64 v128)))
+ ;; CHECK:      (type $26 (func (param i32 i64 v128)))
 
- ;; CHECK:      (type $26 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $27 (func (param i32 i32 i64 i64)))
 
- ;; CHECK:      (type $27 (func (param i32) (result i32)))
+ ;; CHECK:      (type $28 (func (param i32) (result i32)))
 
- ;; CHECK:      (type $28 (func (param i32 i64) (result i32 i64)))
+ ;; CHECK:      (type $29 (func (param i32 i64) (result i32 i64)))
 
- ;; CHECK:      (type $29 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $30 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $30 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $31 (func (param i32) (result i32 i64)))
 
- ;; CHECK:      (type $31 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $32 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $32 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $33 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $33 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $34 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $34 (func (param i31ref)))
+ ;; CHECK:      (type $35 (func (param i31ref)))
 
- ;; CHECK:      (type $35 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $36 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $36 (func (result (ref $pair))))
+ ;; CHECK:      (type $37 (func (result (ref $pair))))
 
- ;; CHECK:      (type $37 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $38 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $38 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $39 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $39 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $40 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $40 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $41 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $41 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $42 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $42 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $43 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $43 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $44 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $44 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $45 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $45 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $46 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $46 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $47 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $47 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $48 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $48 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $49 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $49 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $50 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $50 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $51 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $51 (func (param externref)))
+ ;; CHECK:      (type $52 (func (param externref)))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -156,16 +158,27 @@
  ;; CHECK:      (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))
  (type $submany (sub $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))
 
- ;; globals
+ ;; imported globals
  (global $g1 (export "g1") (export "g1.1") (import "mod" "g1") i32)
  (global $g2 (import "mod" "g2") (mut i64))
  (global (import "" "g3") (ref 0))
  (global (import "mod" "") (ref null $many))
 
+ ;; imported memories
+ (memory (export "mem") (export "mem2") (import "" "mem") 0)
+
+ ;; imported functions
+ (func (export "f5.0") (export "f5.1") (import "mod" "f5"))
+
+ ;; imported tags
+ (tag $imported (export "t0.0") (export "t0.1") (import "mod" "t0") (param i32 i64))
+ (tag (import "mod" "t1"))
+
+ ;; globals
  (global (mut i32) i32.const 0)
- ;; CHECK:      (type $62 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany))))
+ ;; CHECK:      (type $63 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany))))
 
- ;; CHECK:      (import "" "mem" (memory $mimport$1 0))
+ ;; CHECK:      (import "" "mem" (memory $mimport$0 0))
 
  ;; CHECK:      (import "mod" "g1" (global $g1 i32))
 
@@ -175,7 +188,11 @@
 
  ;; CHECK:      (import "mod" "" (global $gimport$1 (ref null $many)))
 
- ;; CHECK:      (import "mod" "f5" (func $fimport$1 (type $void)))
+ ;; CHECK:      (import "mod" "f5" (func $fimport$0 (type $void)))
+
+ ;; CHECK:      (import "mod" "t0" (tag $imported (param i32 i64)))
+
+ ;; CHECK:      (import "mod" "t1" (tag $timport$0))
 
  ;; CHECK:      (global $2 (mut i32) (i32.const 0))
 
@@ -186,13 +203,14 @@
  ;; CHECK:      (memory $mem (shared 1 1))
  (memory $mem 1 1 shared)
  (memory 0 1 shared)
- ;; CHECK:      (memory $0 (shared 0 1))
+ ;; CHECK:      (memory $1 (shared 0 1))
 
  ;; CHECK:      (memory $mem-i32 0 1)
  (memory $mem-i32 i32 0 1)
+
  ;; CHECK:      (memory $mem-i64 i64 2)
  (memory $mem-i64 i64 2)
- (memory (export "mem") (export "mem2") (import "" "mem") 0)
+
  ;; CHECK:      (memory $mem-init 1 1)
  (memory $mem-init (data "hello inline data"))
 
@@ -204,36 +222,58 @@
 
  ;; CHECK:      (data $passive "hello again")
  (data $passive "hello" " " "again")
+
  ;; CHECK:      (data $active (i32.const 0) "active hello")
  (data $active (offset i32.const 0) "active hello" "" "")
+
  ;; CHECK:      (data $active2 (i32.const 1) "active again!")
  (data $active2 (offset (i32.const 1)) "" "active again" "!")
- ;; CHECK:      (data $active3 (i32.const 42) "active abbreviated")
+
+ ;; CHECK:      (data $active3 (memory $mem) (i32.const 42) "active abbreviated")
  (data $active3 (memory $mem) (i32.const 42) "" "active abbreviated" "")
+
  ;; CHECK:      (data $active4 (memory $mem-i32) (i32.const 16) "")
  (data $active4 (memory $mem-i32) (i32.const 16) "")
- (data (memory 3) (offset i64.const 0) "64-bit")
 
- ;; functions
- (func)
+ (data (memory 4) (offset i64.const 0) "64-bit")
 
+ ;; tags
+ (tag)
  ;; CHECK:      (data $1 (memory $mem-i64) (i64.const 0) "64-bit")
 
  ;; CHECK:      (elem declare func $ref-func)
 
+ ;; CHECK:      (tag $1)
+
+ ;; CHECK:      (tag $empty)
+ (tag $empty)
+
+ ;; CHECK:      (tag $tag-i32 (param i32))
+ (tag $tag-i32 (param $x i32))
+
+ ;; CHECK:      (tag $tag-pair (param i32 i64))
+ (tag $tag-pair (param i32 i64))
+
+ ;; functions
+ (func)
+
  ;; CHECK:      (export "g1" (global $g1))
 
  ;; CHECK:      (export "g1.1" (global $g1))
 
- ;; CHECK:      (export "mem" (memory $mimport$1))
+ ;; CHECK:      (export "mem" (memory $mimport$0))
+
+ ;; CHECK:      (export "mem2" (memory $mimport$0))
 
- ;; CHECK:      (export "mem2" (memory $mimport$1))
+ ;; CHECK:      (export "f5.0" (func $fimport$0))
 
- ;; CHECK:      (export "f5.0" (func $fimport$1))
+ ;; CHECK:      (export "f5.1" (func $fimport$0))
 
- ;; CHECK:      (export "f5.1" (func $fimport$1))
+ ;; CHECK:      (export "t0.0" (tag $imported))
 
- ;; CHECK:      (func $0 (type $void)
+ ;; CHECK:      (export "t0.1" (tag $imported))
+
+ ;; CHECK:      (func $1 (type $void)
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
 
@@ -258,7 +298,6 @@
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $f4 (type 17) (local i32 i64) (local $l f32))
- (func (export "f5.0") (export "f5.1") (import "mod" "f5"))
 
  ;; CHECK:      (func $nop-skate (type $void)
  ;; CHECK-NEXT:  (nop)
@@ -685,7 +724,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $19) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $20) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -1616,8 +1655,8 @@
   br 0
  )
 
- ;; CHECK:      (func $br-multivalue (type $4) (result i32 i64)
- ;; CHECK-NEXT:  (block $label (type $4) (result i32 i64)
+ ;; CHECK:      (func $br-multivalue (type $5) (result i32 i64)
+ ;; CHECK-NEXT:  (block $label (type $5) (result i32 i64)
  ;; CHECK-NEXT:   (br $label
  ;; CHECK-NEXT:    (tuple.make
  ;; CHECK-NEXT:     (i32.const 0)
@@ -1632,9 +1671,9 @@
   br 0
  )
 
- ;; CHECK:      (func $br-multivalue-drop (type $4) (result i32 i64)
- ;; CHECK-NEXT:  (block $label (type $4) (result i32 i64)
- ;; CHECK-NEXT:   (block (type $4) (result i32 i64)
+ ;; CHECK:      (func $br-multivalue-drop (type $5) (result i32 i64)
+ ;; CHECK-NEXT:  (block $label (type $5) (result i32 i64)
+ ;; CHECK-NEXT:   (block (type $5) (result i32 i64)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (f32.const 0)
  ;; CHECK-NEXT:    )
@@ -1738,9 +1777,9 @@
   end
  )
 
- ;; CHECK:      (func $br-table-multivalue (type $4) (result i32 i64)
- ;; CHECK-NEXT:  (block $a (type $4) (result i32 i64)
- ;; CHECK-NEXT:   (block $b (type $4) (result i32 i64)
+ ;; CHECK:      (func $br-table-multivalue (type $5) (result i32 i64)
+ ;; CHECK-NEXT:  (block $a (type $5) (result i32 i64)
+ ;; CHECK-NEXT:   (block $b (type $5) (result i32 i64)
  ;; CHECK-NEXT:    (br_table $a $b
  ;; CHECK-NEXT:     (tuple.make
  ;; CHECK-NEXT:      (i32.const 42)
@@ -1763,7 +1802,7 @@
  )
 
 
- ;; CHECK:      (func $binary (type $20) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $21) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -1788,7 +1827,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $21) (param $0 i64)
+ ;; CHECK:      (func $unary (type $22) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -1801,7 +1840,7 @@
   drop
  )
 
- ;; CHECK:      (func $select (type $12) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $select (type $13) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (select
  ;; CHECK-NEXT:    (local.get $0)
@@ -1856,10 +1895,10 @@
 
  ;; CHECK:      (func $memory-size (type $void)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.size $mem)
+ ;; CHECK-NEXT:   (memory.size $mimport$0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.size $0)
+ ;; CHECK-NEXT:   (memory.size $mem)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (memory.size $mem-i64)
@@ -1874,14 +1913,14 @@
   drop
  )
 
- ;; CHECK:      (func $memory-grow (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $memory-grow (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.grow $mem
+ ;; CHECK-NEXT:   (memory.grow $mimport$0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.grow $0
+ ;; CHECK-NEXT:   (memory.grow $mem
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
@@ -1913,14 +1952,14 @@
   global.set 4
  )
 
- ;; CHECK:      (func $load (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $load (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (i32.load $mem offset=42
+ ;; CHECK-NEXT:   (i32.load $mimport$0 offset=42
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (i64.load8_s $0
+ ;; CHECK-NEXT:   (i64.load8_s $mem
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
@@ -1942,12 +1981,12 @@
   drop
  )
 
- ;; CHECK:      (func $store (type $5) (param $0 i32) (param $1 i64)
- ;; CHECK-NEXT:  (i32.store $mem offset=42 align=1
+ ;; CHECK:      (func $store (type $4) (param $0 i32) (param $1 i64)
+ ;; CHECK-NEXT:  (i32.store $mimport$0 offset=42 align=1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (i64.atomic.store8 $0
+ ;; CHECK-NEXT:  (i64.atomic.store8 $mem
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
@@ -1968,9 +2007,9 @@
   f32.store $mem-i64
  )
 
- ;; CHECK:      (func $atomic-rmw (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $atomic-rmw (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (i32.atomic.rmw16.add_u $mem
+ ;; CHECK-NEXT:   (i32.atomic.rmw16.add_u $mimport$0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
@@ -1993,7 +2032,7 @@
   drop
  )
 
- ;; CHECK:      (func $atomic-cmpxchg (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $atomic-cmpxchg (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.atomic.rmw8.cmpxchg_u $mem
  ;; CHECK-NEXT:    (local.get $0)
@@ -2013,18 +2052,18 @@
   local.get 0
   i32.const 1
   i32.const 2
-  i32.atomic.rmw8.cmpxchg_u 0 align=1
+  i32.atomic.rmw8.cmpxchg_u 1 align=1
   drop
   local.get 1
   i64.const 3
   i64.const 4
-  i64.atomic.rmw32.cmpxchg_u 3 offset=16
+  i64.atomic.rmw32.cmpxchg_u 4 offset=16
   drop
  )
 
- ;; CHECK:      (func $atomic-wait (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $atomic-wait (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.atomic.wait32 $mem
+ ;; CHECK-NEXT:   (memory.atomic.wait32 $mimport$0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:    (i64.const 2)
@@ -2051,9 +2090,9 @@
   drop
  )
 
- ;; CHECK:      (func $atomic-notify (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $atomic-notify (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (memory.atomic.notify $mem offset=8
+ ;; CHECK-NEXT:   (memory.atomic.notify $mimport$0 offset=8
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
@@ -2083,7 +2122,7 @@
   atomic.fence
  )
 
- ;; CHECK:      (func $simd-extract (type $22) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $23) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2093,7 +2132,7 @@
   i32x4.extract_lane 3
  )
 
- ;; CHECK:      (func $simd-replace (type $13) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-replace (type $14) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i32x4.replace_lane 2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2105,7 +2144,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $23) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $24) (param $0 v128) (param $1 v128) (result v128)
  ;; CHECK-NEXT:  (i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2117,7 +2156,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $24) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $25) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
  ;; CHECK-NEXT:  (v128.bitselect
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2131,7 +2170,7 @@
   v128.bitselect
  )
 
- ;; CHECK:      (func $simd-shift (type $13) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-shift (type $14) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i8x16.shl
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2143,9 +2182,9 @@
   i8x16.shl
  )
 
- ;; CHECK:      (func $simd-load (type $5) (param $0 i32) (param $1 i64)
+ ;; CHECK:      (func $simd-load (type $4) (param $0 i32) (param $1 i64)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (v128.load8x8_s $mem offset=8
+ ;; CHECK-NEXT:   (v128.load8x8_s $mimport$0 offset=8
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
@@ -2164,9 +2203,9 @@
   drop
  )
 
- ;; CHECK:      (func $simd-load-store-lane (type $25) (param $0 i32) (param $1 i64) (param $2 v128)
+ ;; CHECK:      (func $simd-load-store-lane (type $26) (param $0 i32) (param $1 i64) (param $2 v128)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (v128.load16_lane $mem 7
+ ;; CHECK-NEXT:   (v128.load16_lane $mimport$0 7
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
@@ -2183,10 +2222,10 @@
   drop
   local.get 1
   local.get 2
-  v128.store64_lane 3 align=4 0
+  v128.store64_lane 4 align=4 0
  )
 
- ;; CHECK:      (func $memory-init (type $12) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $memory-init (type $13) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (memory.init $mem-i32 $passive
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2197,7 +2236,7 @@
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (memory.init $mem $implicit-data
+ ;; CHECK-NEXT:  (memory.init $mimport$0 $implicit-data
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
@@ -2211,7 +2250,7 @@
   i64.const 0
   local.get 1
   local.get 2
-  memory.init 3 1
+  memory.init 4 1
   local.get 0
   local.get 1
   local.get 2
@@ -2227,8 +2266,8 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $26) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
- ;; CHECK-NEXT:  (memory.copy $mem $mem
+ ;; CHECK:      (func $memory-copy (type $27) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK-NEXT:  (memory.copy $mimport$0 $mimport$0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.const 2)
@@ -2252,20 +2291,20 @@
   local.get 0
   local.get 1
   i32.const 3
-  memory.copy 0 $mem-i32
+  memory.copy 1 $mem-i32
   local.get 2
   local.get 3
   i64.const 4
-  memory.copy $mem-i64 3
+  memory.copy $mem-i64 4
  )
 
- ;; CHECK:      (func $memory-fill (type $5) (param $0 i32) (param $1 i64)
- ;; CHECK-NEXT:  (memory.fill $mem
+ ;; CHECK:      (func $memory-fill (type $4) (param $0 i32) (param $1 i64)
+ ;; CHECK-NEXT:  (memory.fill $mimport$0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (memory.fill $mem
+ ;; CHECK-NEXT:  (memory.fill $mimport$0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 3)
  ;; CHECK-NEXT:   (i32.const 4)
@@ -2298,7 +2337,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $27) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $28) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2308,7 +2347,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two (type $28) (param $0 i32) (param $1 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two (type $29) (param $0 i32) (param $1 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make
  ;; CHECK-NEXT:    (local.get $0)
@@ -2322,7 +2361,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $29) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $30) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make
  ;; CHECK-NEXT:    (unreachable)
@@ -2336,7 +2375,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $30) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $31) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2353,7 +2392,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $31) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $32) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2378,7 +2417,26 @@
   drop
  )
 
- ;; CHECK:      (func $ref-eq (type $32) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $throw (type $void)
+ ;; CHECK-NEXT:  (throw $1)
+ ;; CHECK-NEXT:  (throw $tag-i32
+ ;; CHECK-NEXT:   (i32.const 0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (throw $tag-pair
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:   (i64.const 2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $throw
+  throw 2
+  i32.const 0
+  throw $tag-i32
+  i32.const 1
+  i64.const 2
+  throw $tag-pair
+ )
+
+ ;; CHECK:      (func $ref-eq (type $33) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2390,7 +2448,7 @@
   ref.eq
  )
 
- ;; CHECK:      (func $i31-new (type $33) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $34) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2400,7 +2458,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $34) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $35) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -2625,7 +2683,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $35) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $36) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2637,14 +2695,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $36) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $37) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new_default $pair)
  ;; CHECK-NEXT: )
  (func $struct-new-default (result (ref $pair))
   struct.new_default 14
  )
 
- ;; CHECK:      (func $struct-get-0 (type $37) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $38) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2654,7 +2712,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $38) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $39) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2664,7 +2722,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-set-0 (type $39) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $40) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2676,7 +2734,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $40) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $41) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2688,7 +2746,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $array-new (type $41) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $42) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2700,7 +2758,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $42) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $43) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2710,7 +2768,7 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $43) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-data (type $44) (param $0 i32) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_data $a1 $implicit-data
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2744,7 +2802,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $44) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $45) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2756,7 +2814,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $45) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $46) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (array.get_s $packed-i8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2768,7 +2826,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $46) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $47) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (array.get_u $packed-i16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2780,7 +2838,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $47) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $48) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
  ;; CHECK-NEXT:  (array.set $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2794,7 +2852,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $48) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $49) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2804,7 +2862,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $49) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $50) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
  ;; CHECK-NEXT:  (array.copy $a2 $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2822,7 +2880,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $50) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $51) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
  ;; CHECK-NEXT:  (array.fill $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2851,7 +2909,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $51) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $52) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -2877,7 +2935,7 @@
   drop
  )
 
- ;; CHECK:      (func $call (type $18) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $call (type $19) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (call $call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2889,7 +2947,7 @@
   call $call
  )
 
- ;; CHECK:      (func $return_call (type $18) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $return_call (type $19) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (return_call $return_call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2901,7 +2959,7 @@
   return_call $return_call
  )
 
- ;; CHECK:      (func $use-types (type $62) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany))
+ ;; CHECK:      (func $use-types (type $63) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $use-types