[Parser] Parse the remaining array operations (#6158)

Parse `array.new_elem`, `array.init_data`, and `array.init_elem`.

Accidentally also includes:

* [Parser] Parse string types and operations (#6161)

8 files changed, 941 insertions, 145 deletions

diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 15b82fe64..620d10d60 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -104,6 +104,10 @@ struct NullTypeParserCtx {
   HeapTypeT makeI31() { return Ok{}; }
   HeapTypeT makeStructType() { return Ok{}; }
   HeapTypeT makeArrayType() { return Ok{}; }
+  HeapTypeT makeStringType() { return Ok{}; }
+  HeapTypeT makeStringViewWTF8Type() { return Ok{}; }
+  HeapTypeT makeStringViewWTF16Type() { return Ok{}; }
+  HeapTypeT makeStringViewIterType() { return Ok{}; }
 
   TypeT makeI32() { return Ok{}; }
   TypeT makeI64() { return Ok{}; }
@@ -190,6 +194,10 @@ template<typename Ctx> struct TypeParserCtx {
   HeapTypeT makeI31() { return HeapType::i31; }
   HeapTypeT makeStructType() { return HeapType::struct_; }
   HeapTypeT makeArrayType() { return HeapType::array; }
+  HeapTypeT makeStringType() { return HeapType::string; }
+  HeapTypeT makeStringViewWTF8Type() { return HeapType::stringview_wtf8; }
+  HeapTypeT makeStringViewWTF16Type() { return HeapType::stringview_wtf16; }
+  HeapTypeT makeStringViewIterType() { return HeapType::stringview_iter; }
 
   TypeT makeI32() { return Type::i32; }
   TypeT makeI64() { return Type::i64; }
@@ -284,8 +292,9 @@ struct NullInstrParserCtx {
   using FuncIdxT = Ok;
   using LocalIdxT = Ok;
   using TableIdxT = Ok;
-  using GlobalIdxT = Ok;
   using MemoryIdxT = Ok;
+  using GlobalIdxT = Ok;
+  using ElemIdxT = Ok;
   using DataIdxT = Ok;
   using LabelIdxT = Ok;
   using TagIdxT = Ok;
@@ -310,6 +319,8 @@ struct NullInstrParserCtx {
   TableIdxT getTableFromName(Name) { return Ok{}; }
   MemoryIdxT getMemoryFromIdx(uint32_t) { return Ok{}; }
   MemoryIdxT getMemoryFromName(Name) { return Ok{}; }
+  ElemIdxT getElemFromIdx(uint32_t) { return Ok{}; }
+  ElemIdxT getElemFromName(Name) { return Ok{}; }
   DataIdxT getDataFromIdx(uint32_t) { return Ok{}; }
   DataIdxT getDataFromName(Name) { return Ok{}; }
   LabelIdxT getLabelFromIdx(uint32_t, bool) { return Ok{}; }
@@ -458,7 +469,7 @@ struct NullInstrParserCtx {
     return Ok{};
   }
   template<typename HeapTypeT>
-  Result<> makeArrayNewElem(Index, HeapTypeT, DataIdxT) {
+  Result<> makeArrayNewElem(Index, HeapTypeT, ElemIdxT) {
     return Ok{};
   }
   template<typename HeapTypeT>
@@ -479,7 +490,28 @@ struct NullInstrParserCtx {
   template<typename HeapTypeT> Result<> makeArrayFill(Index, HeapTypeT) {
     return Ok{};
   }
+  template<typename HeapTypeT>
+  Result<> makeArrayInitData(Index, HeapTypeT, DataIdxT) {
+    return Ok{};
+  }
+  template<typename HeapTypeT>
+  Result<> makeArrayInitElem(Index, HeapTypeT, ElemIdxT) {
+    return Ok{};
+  }
   Result<> makeRefAs(Index, RefAsOp) { return Ok{}; }
+  Result<> makeStringNew(Index, StringNewOp, bool, MemoryIdxT*) { return Ok{}; }
+  Result<> makeStringConst(Index, std::string_view) { return Ok{}; }
+  Result<> makeStringMeasure(Index, StringMeasureOp) { return Ok{}; }
+  Result<> makeStringEncode(Index, StringEncodeOp, MemoryIdxT*) { return Ok{}; }
+  Result<> makeStringConcat(Index) { return Ok{}; }
+  Result<> makeStringEq(Index, StringEqOp) { return Ok{}; }
+  Result<> makeStringAs(Index, StringAsOp) { return Ok{}; }
+  Result<> makeStringWTF8Advance(Index) { return Ok{}; }
+  Result<> makeStringWTF16Get(Index) { return Ok{}; }
+  Result<> makeStringIterNext(Index) { return Ok{}; }
+  Result<> makeStringIterMove(Index, StringIterMoveOp) { return Ok{}; }
+  Result<> makeStringSliceWTF(Index, StringSliceWTFOp) { return Ok{}; }
+  Result<> makeStringSliceIter(Index) { return Ok{}; }
 };
 
 // Phase 1: Parse definition spans for top-level module elements and determine
@@ -968,6 +1000,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
   using GlobalIdxT = Name;
   using TableIdxT = Name;
   using MemoryIdxT = Name;
+  using ElemIdxT = Name;
   using DataIdxT = Name;
   using TagIdxT = Name;
 
@@ -1141,6 +1174,20 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return name;
   }
 
+  Result<Name> getElemFromIdx(uint32_t idx) {
+    if (idx >= wasm.elementSegments.size()) {
+      return in.err("elem index out of bounds");
+    }
+    return wasm.elementSegments[idx]->name;
+  }
+
+  Result<Name> getElemFromName(Name name) {
+    if (!wasm.getElementSegmentOrNull(name)) {
+      return in.err("elem $" + name.toString() + " does not exist");
+    }
+    return name;
+  }
+
   Result<Name> getDataFromIdx(uint32_t idx) {
     if (idx >= wasm.dataSegments.size()) {
       return in.err("data index out of bounds");
@@ -1658,9 +1705,73 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeArrayFill(type));
   }
 
+  Result<> makeArrayInitData(Index pos, HeapType type, Name data) {
+    return withLoc(pos, irBuilder.makeArrayInitData(type, data));
+  }
+
+  Result<> makeArrayInitElem(Index pos, HeapType type, Name elem) {
+    return withLoc(pos, irBuilder.makeArrayInitElem(type, elem));
+  }
+
   Result<> makeRefAs(Index pos, RefAsOp op) {
     return withLoc(pos, irBuilder.makeRefAs(op));
   }
+
+  Result<> makeStringNew(Index pos, StringNewOp op, bool try_, Name* mem) {
+    auto m = getMemory(pos, mem);
+    CHECK_ERR(m);
+    return withLoc(pos, irBuilder.makeStringNew(op, try_, *m));
+  }
+
+  Result<> makeStringConst(Index pos, std::string_view str) {
+    return withLoc(pos, irBuilder.makeStringConst(Name(str)));
+  }
+
+  Result<> makeStringMeasure(Index pos, StringMeasureOp op) {
+    return withLoc(pos, irBuilder.makeStringMeasure(op));
+  }
+
+  Result<> makeStringEncode(Index pos, StringEncodeOp op, Name* mem) {
+    auto m = getMemory(pos, mem);
+    CHECK_ERR(m);
+    return withLoc(pos, irBuilder.makeStringEncode(op, *m));
+  }
+
+  Result<> makeStringConcat(Index pos) {
+    return withLoc(pos, irBuilder.makeStringConcat());
+  }
+
+  Result<> makeStringEq(Index pos, StringEqOp op) {
+    return withLoc(pos, irBuilder.makeStringEq(op));
+  }
+
+  Result<> makeStringAs(Index pos, StringAsOp op) {
+    return withLoc(pos, irBuilder.makeStringAs(op));
+  }
+
+  Result<> makeStringWTF8Advance(Index pos) {
+    return withLoc(pos, irBuilder.makeStringWTF8Advance());
+  }
+
+  Result<> makeStringWTF16Get(Index pos) {
+    return withLoc(pos, irBuilder.makeStringWTF16Get());
+  }
+
+  Result<> makeStringIterNext(Index pos) {
+    return withLoc(pos, irBuilder.makeStringIterNext());
+  }
+
+  Result<> makeStringIterMove(Index pos, StringIterMoveOp op) {
+    return withLoc(pos, irBuilder.makeStringIterMove(op));
+  }
+
+  Result<> makeStringSliceWTF(Index pos, StringSliceWTFOp op) {
+    return withLoc(pos, irBuilder.makeStringSliceWTF(op));
+  }
+
+  Result<> makeStringSliceIter(Index pos) {
+    return withLoc(pos, irBuilder.makeStringSliceIter());
+  }
 };
 
 } // namespace wasm::WATParser
diff --git a/src/parser/input-impl.h b/src/parser/input-impl.h
index 7ee358f12..0f8fc2e86 100644
--- a/src/parser/input-impl.h
+++ b/src/parser/input-impl.h
@@ -226,11 +226,11 @@ inline std::optional<float> ParseInput::takeF32() {
   return std::nullopt;
 }
 
-inline std::optional<std::string_view> ParseInput::takeString() {
+inline std::optional<std::string> ParseInput::takeString() {
   if (auto t = peek()) {
     if (auto s = t->getString()) {
       ++lexer;
-      return s;
+      return std::string(*s);
     }
   }
   return {};
diff --git a/src/parser/input.h b/src/parser/input.h
index 5cb2bd471..dbf3e4868 100644
--- a/src/parser/input.h
+++ b/src/parser/input.h
@@ -59,7 +59,7 @@ struct ParseInput {
   std::optional<uint8_t> takeU8();
   std::optional<double> takeF64();
   std::optional<float> takeF32();
-  std::optional<std::string_view> takeString();
+  std::optional<std::string> takeString();
   std::optional<Name> takeName();
   bool takeSExprStart(std::string_view expected);
   bool peekSExprStart(std::string_view expected);
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index be8db49a9..4909ad057 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -176,6 +176,8 @@ template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::MemoryIdxT> memidx(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemuse(Ctx&);
 template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::LocalIdxT> localidx(Ctx&);
 template<typename Ctx>
 Result<typename Ctx::LabelIdxT> labelidx(Ctx&, bool inDelegate = false);
@@ -249,6 +251,18 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
   if (ctx.in.takeKeyword("array"sv)) {
     return ctx.makeArrayType();
   }
+  if (ctx.in.takeKeyword("string"sv)) {
+    return ctx.makeStringType();
+  }
+  if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+    return ctx.makeStringViewWTF8Type();
+  }
+  if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+    return ctx.makeStringViewWTF16Type();
+  }
+  if (ctx.in.takeKeyword("stringview_iter"sv)) {
+    return ctx.makeStringViewIterType();
+  }
   auto type = typeidx(ctx);
   CHECK_ERR(type);
   return *type;
@@ -282,7 +296,19 @@ template<typename Ctx> MaybeResult<typename Ctx::TypeT> reftype(Ctx& ctx) {
     return ctx.makeRefType(ctx.makeStructType(), Nullable);
   }
   if (ctx.in.takeKeyword("arrayref"sv)) {
-    return ctx.in.err("arrayref not yet supported");
+    return ctx.makeRefType(ctx.makeArrayType(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringref"sv)) {
+    return ctx.makeRefType(ctx.makeStringType(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewWTF8Type(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewWTF16Type(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_iter"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewIterType(), Nullable);
   }
 
   if (!ctx.in.takeSExprStart("ref"sv)) {
@@ -1584,7 +1610,11 @@ template<typename Ctx> Result<> makeArrayNewData(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeArrayNewElem(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto elem = elemidx(ctx);
+  CHECK_ERR(elem);
+  return ctx.makeArrayNewElem(pos, *type, *elem);
 }
 
 template<typename Ctx> Result<> makeArrayNewFixed(Ctx& ctx, Index pos) {
@@ -1629,11 +1659,18 @@ template<typename Ctx> Result<> makeArrayFill(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeArrayInitData(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto data = dataidx(ctx);
+  CHECK_ERR(data);
+  return ctx.makeArrayInitData(pos, *type, *data);
 }
 
 template<typename Ctx> Result<> makeArrayInitElem(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto elem = elemidx(ctx);
+  return ctx.makeArrayInitElem(pos, *type, *elem);
 }
 
 template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
@@ -1642,61 +1679,69 @@ template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
 
 template<typename Ctx>
 Result<> makeStringNew(Ctx& ctx, Index pos, StringNewOp op, bool try_) {
-  return ctx.in.err("unimplemented instruction");
+  auto mem = maybeMemidx(ctx);
+  CHECK_ERR(mem);
+  return ctx.makeStringNew(pos, op, try_, mem.getPtr());
 }
 
 template<typename Ctx> Result<> makeStringConst(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto str = ctx.in.takeString();
+  if (!str) {
+    return ctx.in.err("expected string");
+  }
+  return ctx.makeStringConst(pos, *str);
 }
 
 template<typename Ctx>
 Result<> makeStringMeasure(Ctx& ctx, Index pos, StringMeasureOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringMeasure(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringEncode(Ctx& ctx, Index pos, StringEncodeOp op) {
-  return ctx.in.err("unimplemented instruction");
+  auto mem = maybeMemidx(ctx);
+  CHECK_ERR(mem);
+  return ctx.makeStringEncode(pos, op, mem.getPtr());
 }
 
 template<typename Ctx> Result<> makeStringConcat(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringConcat(pos);
 }
 
 template<typename Ctx>
 Result<> makeStringEq(Ctx& ctx, Index pos, StringEqOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringEq(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringAs(Ctx& ctx, Index pos, StringAsOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringAs(pos, op);
 }
 
 template<typename Ctx> Result<> makeStringWTF8Advance(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringWTF8Advance(pos);
 }
 
 template<typename Ctx> Result<> makeStringWTF16Get(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringWTF16Get(pos);
 }
 
 template<typename Ctx> Result<> makeStringIterNext(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringIterNext(pos);
 }
 
 template<typename Ctx>
 Result<> makeStringIterMove(Ctx& ctx, Index pos, StringIterMoveOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringIterMove(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringSliceWTF(Ctx& ctx, Index pos, StringSliceWTFOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringSliceWTF(pos, op);
 }
 
 template<typename Ctx> Result<> makeStringSliceIter(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringSliceIter(pos);
 }
 
 // =======
@@ -1843,8 +1888,20 @@ template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx& ctx) {
   return ctx.in.err("expected global index or identifier");
 }
 
+// elemidx ::= x:u32 => x
+//           | v:id => x (if elems[x] = v)
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx& ctx) {
+  if (auto x = ctx.in.takeU32()) {
+    return ctx.getElemFromIdx(*x);
+  }
+  if (auto id = ctx.in.takeID()) {
+    return ctx.getElemFromName(*id);
+  }
+  return ctx.in.err("expected elem index or identifier");
+}
+
 // dataidx ::= x:u32 => x
-//           | v:id => x (if data[x] = v)
+//           | v:id => x (if datas[x] = v)
 template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx& ctx) {
   if (auto x = ctx.in.takeU32()) {
     return ctx.getDataFromIdx(*x);
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index a7e36bd10..8b01977be 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -181,22 +181,22 @@ public:
   [[nodiscard]] Result<> makeArrayLen();
   [[nodiscard]] Result<> makeArrayCopy(HeapType destType, HeapType srcType);
   [[nodiscard]] Result<> makeArrayFill(HeapType type);
-  // [[nodiscard]] Result<> makeArrayInitData();
-  // [[nodiscard]] Result<> makeArrayInitElem();
+  [[nodiscard]] Result<> makeArrayInitData(HeapType type, Name data);
+  [[nodiscard]] Result<> makeArrayInitElem(HeapType type, Name elem);
   [[nodiscard]] Result<> makeRefAs(RefAsOp op);
-  // [[nodiscard]] Result<> makeStringNew();
-  // [[nodiscard]] Result<> makeStringConst();
-  // [[nodiscard]] Result<> makeStringMeasure();
-  // [[nodiscard]] Result<> makeStringEncode();
-  // [[nodiscard]] Result<> makeStringConcat();
-  // [[nodiscard]] Result<> makeStringEq();
-  // [[nodiscard]] Result<> makeStringAs();
-  // [[nodiscard]] Result<> makeStringWTF8Advance();
-  // [[nodiscard]] Result<> makeStringWTF16Get();
-  // [[nodiscard]] Result<> makeStringIterNext();
-  // [[nodiscard]] Result<> makeStringIterMove();
-  // [[nodiscard]] Result<> makeStringSliceWTF();
-  // [[nodiscard]] Result<> makeStringSliceIter();
+  [[nodiscard]] Result<> makeStringNew(StringNewOp op, bool try_, Name mem);
+  [[nodiscard]] Result<> makeStringConst(Name string);
+  [[nodiscard]] Result<> makeStringMeasure(StringMeasureOp op);
+  [[nodiscard]] Result<> makeStringEncode(StringEncodeOp op, Name mem);
+  [[nodiscard]] Result<> makeStringConcat();
+  [[nodiscard]] Result<> makeStringEq(StringEqOp op);
+  [[nodiscard]] Result<> makeStringAs(StringAsOp op);
+  [[nodiscard]] Result<> makeStringWTF8Advance();
+  [[nodiscard]] Result<> makeStringWTF16Get();
+  [[nodiscard]] Result<> makeStringIterNext();
+  [[nodiscard]] Result<> makeStringIterMove(StringIterMoveOp op);
+  [[nodiscard]] Result<> makeStringSliceWTF(StringSliceWTFOp op);
+  [[nodiscard]] Result<> makeStringSliceIter();
 
   // Private functions that must be public for technical reasons.
   [[nodiscard]] Result<> visitExpression(Expression*);
@@ -213,6 +213,8 @@ public:
   [[nodiscard]] Result<> visitCallIndirect(CallIndirect*);
   [[nodiscard]] Result<> visitCallRef(CallRef*);
   [[nodiscard]] Result<> visitThrow(Throw*);
+  [[nodiscard]] Result<> visitStringNew(StringNew*);
+  [[nodiscard]] Result<> visitStringEncode(StringEncode*);
 
 private:
   Module& wasm;
diff --git a/src/wasm.h b/src/wasm.h
index 7da80d896..ce334773a 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -1736,6 +1736,7 @@ public:
 
 class ArrayInitData : public SpecificExpression<Expression::ArrayInitDataId> {
 public:
+  ArrayInitData() = default;
   ArrayInitData(MixedArena& allocator) {}
 
   Name segment;
@@ -1749,6 +1750,7 @@ public:
 
 class ArrayInitElem : public SpecificExpression<Expression::ArrayInitElemId> {
 public:
+  ArrayInitElem() = default;
   ArrayInitElem(MixedArena& allocator) {}
 
   Name segment;
@@ -1774,6 +1776,7 @@ public:
 
 class StringNew : public SpecificExpression<Expression::StringNewId> {
 public:
+  StringNew() = default;
   StringNew(MixedArena& allocator) {}
 
   StringNewOp op;
@@ -1798,6 +1801,7 @@ public:
 
 class StringConst : public SpecificExpression<Expression::StringConstId> {
 public:
+  StringConst() = default;
   StringConst(MixedArena& allocator) {}
 
   // TODO: Use a different type to allow null bytes in the middle -
@@ -1810,6 +1814,7 @@ public:
 
 class StringMeasure : public SpecificExpression<Expression::StringMeasureId> {
 public:
+  StringMeasure() = default;
   StringMeasure(MixedArena& allocator) {}
 
   StringMeasureOp op;
@@ -1821,6 +1826,7 @@ public:
 
 class StringEncode : public SpecificExpression<Expression::StringEncodeId> {
 public:
+  StringEncode() = default;
   StringEncode(MixedArena& allocator) {}
 
   StringEncodeOp op;
@@ -1840,6 +1846,7 @@ public:
 
 class StringConcat : public SpecificExpression<Expression::StringConcatId> {
 public:
+  StringConcat() = default;
   StringConcat(MixedArena& allocator) {}
 
   Expression* left;
@@ -1850,6 +1857,7 @@ public:
 
 class StringEq : public SpecificExpression<Expression::StringEqId> {
 public:
+  StringEq() = default;
   StringEq(MixedArena& allocator) {}
 
   StringEqOp op;
@@ -1862,6 +1870,7 @@ public:
 
 class StringAs : public SpecificExpression<Expression::StringAsId> {
 public:
+  StringAs() = default;
   StringAs(MixedArena& allocator) {}
 
   StringAsOp op;
@@ -1874,6 +1883,7 @@ public:
 class StringWTF8Advance
   : public SpecificExpression<Expression::StringWTF8AdvanceId> {
 public:
+  StringWTF8Advance() = default;
   StringWTF8Advance(MixedArena& allocator) {}
 
   Expression* ref;
@@ -1885,6 +1895,7 @@ public:
 
 class StringWTF16Get : public SpecificExpression<Expression::StringWTF16GetId> {
 public:
+  StringWTF16Get() = default;
   StringWTF16Get(MixedArena& allocator) {}
 
   Expression* ref;
@@ -1895,6 +1906,7 @@ public:
 
 class StringIterNext : public SpecificExpression<Expression::StringIterNextId> {
 public:
+  StringIterNext() = default;
   StringIterNext(MixedArena& allocator) {}
 
   Expression* ref;
@@ -1904,6 +1916,7 @@ public:
 
 class StringIterMove : public SpecificExpression<Expression::StringIterMoveId> {
 public:
+  StringIterMove() = default;
   StringIterMove(MixedArena& allocator) {}
 
   // Whether the movement is to advance or reverse.
@@ -1919,6 +1932,7 @@ public:
 
 class StringSliceWTF : public SpecificExpression<Expression::StringSliceWTFId> {
 public:
+  StringSliceWTF() = default;
   StringSliceWTF(MixedArena& allocator) {}
 
   StringSliceWTFOp op;
@@ -1933,6 +1947,7 @@ public:
 class StringSliceIter
   : public SpecificExpression<Expression::StringSliceIterId> {
 public:
+  StringSliceIter() = default;
   StringSliceIter(MixedArena& allocator) {}
 
   Expression* ref;
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index 5301b75dc..d3f48b1c0 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -471,6 +471,65 @@ Result<> IRBuilder::visitThrow(Throw* curr) {
   return Ok{};
 }
 
+Result<> IRBuilder::visitStringNew(StringNew* curr) {
+  switch (curr->op) {
+    case StringNewUTF8:
+    case StringNewWTF8:
+    case StringNewLossyUTF8:
+    case StringNewWTF16: {
+      auto len = pop();
+      CHECK_ERR(len);
+      curr->length = *len;
+      break;
+    }
+    case StringNewUTF8Array:
+    case StringNewWTF8Array:
+    case StringNewLossyUTF8Array:
+    case StringNewWTF16Array: {
+      auto end = pop();
+      CHECK_ERR(end);
+      curr->end = *end;
+      auto start = pop();
+      CHECK_ERR(start);
+      curr->start = *start;
+      break;
+    }
+    case StringNewFromCodePoint:
+      break;
+  }
+  auto ptr = pop();
+  CHECK_ERR(ptr);
+  curr->ptr = *ptr;
+  return Ok{};
+}
+
+Result<> IRBuilder::visitStringEncode(StringEncode* curr) {
+  switch (curr->op) {
+    case StringEncodeUTF8Array:
+    case StringEncodeLossyUTF8Array:
+    case StringEncodeWTF8Array:
+    case StringEncodeWTF16Array: {
+      auto start = pop();
+      CHECK_ERR(start);
+      curr->start = *start;
+    }
+      [[fallthrough]];
+    case StringEncodeUTF8:
+    case StringEncodeLossyUTF8:
+    case StringEncodeWTF8:
+    case StringEncodeWTF16: {
+      auto ptr = pop();
+      CHECK_ERR(ptr);
+      curr->ptr = *ptr;
+      auto ref = pop();
+      CHECK_ERR(ref);
+      curr->ref = *ref;
+      return Ok{};
+    }
+  }
+  WASM_UNREACHABLE("unexpected op");
+}
+
 Result<> IRBuilder::visitFunctionStart(Function* func) {
   if (!scopeStack.empty()) {
     return Err{"unexpected start of function"};
@@ -1408,9 +1467,23 @@ Result<> IRBuilder::makeArrayFill(HeapType type) {
   return Ok{};
 }
 
-// Result<> IRBuilder::makeArrayInitData() {}
+Result<> IRBuilder::makeArrayInitData(HeapType type, Name data) {
+  ArrayInitData curr;
+  CHECK_ERR(visitArrayInitData(&curr));
+  CHECK_ERR(validateTypeAnnotation(type, curr.ref));
+  push(builder.makeArrayInitData(
+    data, curr.ref, curr.index, curr.offset, curr.size));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeArrayInitElem() {}
+Result<> IRBuilder::makeArrayInitElem(HeapType type, Name elem) {
+  ArrayInitElem curr;
+  CHECK_ERR(visitArrayInitElem(&curr));
+  CHECK_ERR(validateTypeAnnotation(type, curr.ref));
+  push(builder.makeArrayInitElem(
+    elem, curr.ref, curr.index, curr.offset, curr.size));
+  return Ok{};
+}
 
 Result<> IRBuilder::makeRefAs(RefAsOp op) {
   RefAs curr;
@@ -1419,30 +1492,113 @@ Result<> IRBuilder::makeRefAs(RefAsOp op) {
   return Ok{};
 }
 
-// Result<> IRBuilder::makeStringNew() {}
+Result<> IRBuilder::makeStringNew(StringNewOp op, bool try_, Name mem) {
+  StringNew curr;
+  curr.op = op;
+  CHECK_ERR(visitStringNew(&curr));
+  // TODO: Store the memory in the IR.
+  switch (op) {
+    case StringNewUTF8:
+    case StringNewWTF8:
+    case StringNewLossyUTF8:
+    case StringNewWTF16:
+      push(builder.makeStringNew(op, curr.ptr, curr.length, try_));
+      return Ok{};
+    case StringNewUTF8Array:
+    case StringNewWTF8Array:
+    case StringNewLossyUTF8Array:
+    case StringNewWTF16Array:
+      push(builder.makeStringNew(op, curr.ptr, curr.start, curr.end, try_));
+      return Ok{};
+    case StringNewFromCodePoint:
+      push(builder.makeStringNew(op, curr.ptr, nullptr, try_));
+      return Ok{};
+  }
+  WASM_UNREACHABLE("unexpected op");
+}
 
-// Result<> IRBuilder::makeStringConst() {}
+Result<> IRBuilder::makeStringConst(Name string) {
+  push(builder.makeStringConst(string));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringMeasure() {}
+Result<> IRBuilder::makeStringMeasure(StringMeasureOp op) {
+  StringMeasure curr;
+  CHECK_ERR(visitStringMeasure(&curr));
+  push(builder.makeStringMeasure(op, curr.ref));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringEncode() {}
+Result<> IRBuilder::makeStringEncode(StringEncodeOp op, Name mem) {
+  StringEncode curr;
+  curr.op = op;
+  CHECK_ERR(visitStringEncode(&curr));
+  // TODO: Store the memory in the IR.
+  push(builder.makeStringEncode(op, curr.ref, curr.ptr, curr.start));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringConcat() {}
+Result<> IRBuilder::makeStringConcat() {
+  StringConcat curr;
+  CHECK_ERR(visitStringConcat(&curr));
+  push(builder.makeStringConcat(curr.left, curr.right));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringEq() {}
+Result<> IRBuilder::makeStringEq(StringEqOp op) {
+  StringEq curr;
+  CHECK_ERR(visitStringEq(&curr));
+  push(builder.makeStringEq(op, curr.left, curr.right));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringAs() {}
+Result<> IRBuilder::makeStringAs(StringAsOp op) {
+  StringAs curr;
+  CHECK_ERR(visitStringAs(&curr));
+  push(builder.makeStringAs(op, curr.ref));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringWTF8Advance() {}
+Result<> IRBuilder::makeStringWTF8Advance() {
+  StringWTF8Advance curr;
+  CHECK_ERR(visitStringWTF8Advance(&curr));
+  push(builder.makeStringWTF8Advance(curr.ref, curr.pos, curr.bytes));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringWTF16Get() {}
+Result<> IRBuilder::makeStringWTF16Get() {
+  StringWTF16Get curr;
+  CHECK_ERR(visitStringWTF16Get(&curr));
+  push(builder.makeStringWTF16Get(curr.ref, curr.pos));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringIterNext() {}
+Result<> IRBuilder::makeStringIterNext() {
+  StringIterNext curr;
+  CHECK_ERR(visitStringIterNext(&curr));
+  push(builder.makeStringIterNext(curr.ref));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringIterMove() {}
+Result<> IRBuilder::makeStringIterMove(StringIterMoveOp op) {
+  StringIterMove curr;
+  CHECK_ERR(visitStringIterMove(&curr));
+  push(builder.makeStringIterMove(op, curr.ref, curr.num));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringSliceWTF() {}
+Result<> IRBuilder::makeStringSliceWTF(StringSliceWTFOp op) {
+  StringSliceWTF curr;
+  CHECK_ERR(visitStringSliceWTF(&curr));
+  push(builder.makeStringSliceWTF(op, curr.ref, curr.start, curr.end));
+  return Ok{};
+}
 
-// Result<> IRBuilder::makeStringSliceIter() {}
+Result<> IRBuilder::makeStringSliceIter() {
+  StringSliceIter curr;
+  CHECK_ERR(visitStringSliceIter(&curr));
+  push(builder.makeStringSliceIter(curr.ref, curr.num));
+  return Ok{};
+}
 
 } // namespace wasm
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index c4bd48260..31910686b 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -19,10 +19,10 @@
 
   ;; CHECK:      (type $5 (func (result i32 i64)))
 
-  ;; CHECK:      (type $a1 (array i64))
-
   ;; CHECK:      (type $a2 (array (mut f32)))
 
+  ;; CHECK:      (type $a1 (array i64))
+
   ;; CHECK:      (type $8 (func (param anyref)))
 
   ;; CHECK:      (rec
@@ -34,93 +34,141 @@
 
  (rec)
 
+ ;; CHECK:      (type $any-array (array (mut anyref)))
+
+ ;; CHECK:      (type $packed-i8 (array (mut i8)))
+
  ;; CHECK:      (type $many (sub (func (param i32 i64 f32 f64) (result anyref (ref func)))))
 
- ;; CHECK:      (type $12 (func))
+ ;; CHECK:      (type $14 (func))
 
- ;; CHECK:      (type $13 (func (param i32)))
+ ;; CHECK:      (type $15 (func (param i32)))
 
- ;; CHECK:      (type $14 (func (param i32 i64 v128)))
+ ;; CHECK:      (type $16 (func (param i32 i64 v128)))
 
  ;; CHECK:      (type $a0 (array i32))
 
- ;; CHECK:      (type $16 (func (param i32 i32 i32)))
+ ;; CHECK:      (type $18 (func (param i32 i32 i32)))
 
- ;; CHECK:      (type $17 (func (param v128 i32) (result v128)))
-
- ;; CHECK:      (type $packed-i8 (array (mut i8)))
+ ;; CHECK:      (type $19 (func (param v128 i32) (result v128)))
 
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
- ;; CHECK:      (type $20 (func (param i32 i64) (result f32)))
+ ;; CHECK:      (type $21 (func (param stringref)))
+
+ ;; CHECK:      (type $22 (func (param stringref stringref) (result i32)))
+
+ ;; CHECK:      (type $23 (func (param i32 i64) (result f32)))
+
+ ;; CHECK:      (type $24 (func (param i32 i32)))
+
+ ;; CHECK:      (type $25 (func (param i32 i32 f64 f64)))
+
+ ;; CHECK:      (type $26 (func (param i64)))
+
+ ;; CHECK:      (type $27 (func (param v128) (result i32)))
+
+ ;; CHECK:      (type $28 (func (param v128 v128) (result v128)))
+
+ ;; CHECK:      (type $29 (func (param v128 v128 v128) (result v128)))
+
+ ;; CHECK:      (type $30 (func (param i32 i32 i64 i64)))
+
+ ;; CHECK:      (type $31 (func (param i32) (result i32)))
+
+ ;; CHECK:      (type $32 (func (param i32 i64) (result i32 i64)))
 
- ;; CHECK:      (type $21 (func (param i32 i32)))
+ ;; CHECK:      (type $33 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $22 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $34 (func (param i32) (result i32 i64)))
 
- ;; CHECK:      (type $23 (func (param i64)))
+ ;; CHECK:      (type $35 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $24 (func (param v128) (result i32)))
+ ;; CHECK:      (type $36 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $25 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $37 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $26 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $38 (func (param i31ref)))
 
- ;; CHECK:      (type $27 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $39 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $28 (func (param i32) (result i32)))
+ ;; CHECK:      (type $40 (func (result (ref $pair))))
 
- ;; CHECK:      (type $29 (func (param i32 i64) (result i32 i64)))
+ ;; CHECK:      (type $41 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $30 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $42 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $31 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $43 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $32 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $44 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $33 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $45 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $34 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $46 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $35 (func (param i31ref)))
+ ;; CHECK:      (type $47 (func (param i32 i32) (result (ref $any-array))))
 
- ;; CHECK:      (type $36 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $48 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $37 (func (result (ref $pair))))
+ ;; CHECK:      (type $49 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $38 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $50 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $39 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $51 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $40 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $52 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $41 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $53 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $42 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $54 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $43 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $55 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $44 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $56 (func (param (ref $a2) i32 i32 i32)))
 
- ;; CHECK:      (type $45 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $57 (func (param (ref $any-array) i32 i32 i32)))
 
- ;; CHECK:      (type $46 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $58 (func (param externref)))
 
- ;; CHECK:      (type $47 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $59 (func (param i32 i32) (result stringref)))
 
- ;; CHECK:      (type $48 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $60 (func (param (ref $packed-i8) i32 i32) (result stringref)))
 
- ;; CHECK:      (type $49 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $61 (func (param i32) (result stringref)))
 
- ;; CHECK:      (type $50 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $62 (func (result (ref string))))
 
- ;; CHECK:      (type $51 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $63 (func (param stringref) (result i32)))
 
- ;; CHECK:      (type $52 (func (param externref)))
+ ;; CHECK:      (type $64 (func (param stringview_wtf16) (result i32)))
 
- ;; CHECK:      (type $53 (func (param i64 v128) (result v128)))
+ ;; CHECK:      (type $65 (func (param stringref (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $54 (func (param i64 v128)))
+ ;; CHECK:      (type $66 (func (param stringref stringref) (result (ref string))))
+
+ ;; CHECK:      (type $67 (func (param stringref) (result stringview_wtf8)))
+
+ ;; CHECK:      (type $68 (func (param stringref) (result (ref stringview_wtf16))))
+
+ ;; CHECK:      (type $69 (func (param stringref) (result stringview_iter)))
+
+ ;; CHECK:      (type $70 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
+
+ ;; CHECK:      (type $71 (func (param stringview_wtf16 i32) (result i32)))
+
+ ;; CHECK:      (type $72 (func (param stringview_iter) (result i32)))
+
+ ;; CHECK:      (type $73 (func (param stringview_iter i32) (result i32)))
+
+ ;; CHECK:      (type $74 (func (param (ref stringview_iter) i32) (result i32)))
+
+ ;; CHECK:      (type $75 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
+
+ ;; CHECK:      (type $76 (func (param stringview_iter i32) (result (ref string))))
+
+ ;; CHECK:      (type $77 (func (param i64 v128) (result v128)))
+
+ ;; CHECK:      (type $78 (func (param i64 v128)))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -149,6 +197,8 @@
 
  (type $packed-i16 (array (mut i16)))
 
+ (type $any-array (array (mut anyref)))
+
  (rec
    (type $void (sub open (func)))
  )
@@ -183,7 +233,7 @@
 
  ;; globals
  (global (mut i32) i32.const 0)
- ;; CHECK:      (type $65 (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 $89 (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$0 0))
 
@@ -332,11 +382,11 @@
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
 
- ;; CHECK:      (func $f1 (type $13) (param $0 i32)
+ ;; CHECK:      (func $f1 (type $15) (param $0 i32)
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $f1 (param i32))
- ;; CHECK:      (func $f2 (type $13) (param $x i32)
+ ;; CHECK:      (func $f2 (type $15) (param $x i32)
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $f2 (param $x i32))
@@ -352,7 +402,7 @@
  ;; CHECK-NEXT:  (local $l f32)
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
- (func $f4 (type 17) (local i32 i64) (local $l f32))
+ (func $f4 (type 18) (local i32 i64) (local $l f32))
 
  ;; CHECK:      (func $nop-skate (type $void)
  ;; CHECK-NEXT:  (nop)
@@ -779,7 +829,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $21) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $24) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -2467,7 +2517,7 @@
  )
 
 
- ;; CHECK:      (func $binary (type $22) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $25) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -2492,7 +2542,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $23) (param $0 i64)
+ ;; CHECK:      (func $unary (type $26) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -2505,7 +2555,7 @@
   drop
  )
 
- ;; CHECK:      (func $select (type $16) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $select (type $18) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (select
  ;; CHECK-NEXT:    (local.get $0)
@@ -2787,7 +2837,7 @@
   atomic.fence
  )
 
- ;; CHECK:      (func $simd-extract (type $24) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $27) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2797,7 +2847,7 @@
   i32x4.extract_lane 3
  )
 
- ;; CHECK:      (func $simd-replace (type $17) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-replace (type $19) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i32x4.replace_lane 2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2809,7 +2859,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $25) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $28) (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)
@@ -2821,7 +2871,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $26) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $29) (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)
@@ -2835,7 +2885,7 @@
   v128.bitselect
  )
 
- ;; CHECK:      (func $simd-shift (type $17) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-shift (type $19) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i8x16.shl
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2868,7 +2918,7 @@
   drop
  )
 
- ;; CHECK:      (func $simd-load-store-lane (type $14) (param $0 i32) (param $1 i64) (param $2 v128)
+ ;; CHECK:      (func $simd-load-store-lane (type $16) (param $0 i32) (param $1 i64) (param $2 v128)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (v128.load16_lane $mimport$0 7
  ;; CHECK-NEXT:    (local.get $0)
@@ -2890,7 +2940,7 @@
   v128.store64_lane 4 align=4 0
  )
 
- ;; CHECK:      (func $memory-init (type $16) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $memory-init (type $18) (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)
@@ -2931,7 +2981,7 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $27) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK:      (func $memory-copy (type $30) (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)
@@ -3002,7 +3052,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $28) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $31) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3012,7 +3062,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two (type $29) (param $0 i32) (param $1 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two (type $32) (param $0 i32) (param $1 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (local.get $0)
@@ -3026,7 +3076,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $30) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $33) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (unreachable)
@@ -3040,7 +3090,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $31) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $34) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3057,7 +3107,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $32) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $35) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3101,7 +3151,7 @@
   throw $tag-pair
  )
 
- ;; CHECK:      (func $ref-eq (type $33) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $ref-eq (type $36) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3278,7 +3328,7 @@
   table.copy 1 $funcs
  )
 
- ;; CHECK:      (func $i31-new (type $34) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $37) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3288,7 +3338,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $35) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $38) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -3513,7 +3563,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $36) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $39) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3525,14 +3575,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $37) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $40) (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 $38) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $41) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3542,7 +3592,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $39) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $42) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3552,7 +3602,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-set-0 (type $40) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $43) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3564,7 +3614,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $41) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $44) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3576,7 +3626,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $array-new (type $42) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $45) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3588,7 +3638,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $43) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $46) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3598,7 +3648,19 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $44) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-elem (type $47) (param $0 i32) (param $1 i32) (result (ref $any-array))
+ ;; CHECK-NEXT:  (array.new_elem $any-array $passive-2
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $array-new-elem (param i32 i32) (result (ref $any-array))
+  local.get 0
+  local.get 1
+  array.new_elem $any-array $passive-2
+ )
+
+ ;; CHECK:      (func $array-new-data (type $48) (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)
@@ -3632,7 +3694,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $45) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $49) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3644,7 +3706,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $46) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $50) (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)
@@ -3656,7 +3718,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $47) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $51) (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)
@@ -3668,7 +3730,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $48) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $52) (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)
@@ -3682,7 +3744,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $49) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $53) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3692,7 +3754,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $50) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $54) (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)
@@ -3710,7 +3772,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $51) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $55) (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)
@@ -3726,6 +3788,38 @@
   array.fill $a2
  )
 
+ ;; CHECK:      (func $array-init-data (type $56) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK-NEXT:  (array.init_data $a2 $implicit-data
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:   (local.get $2)
+ ;; CHECK-NEXT:   (local.get $3)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $array-init-data (param (ref $a2) i32 i32 i32)
+  local.get 0
+  local.get 1
+  local.get 2
+  local.get 3
+  array.init_data $a2 0
+ )
+
+ ;; CHECK:      (func $array-init-elem (type $57) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK-NEXT:  (array.init_elem $any-array $passive-2
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:   (local.get $2)
+ ;; CHECK-NEXT:   (local.get $3)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $array-init-elem (param (ref $any-array) i32 i32 i32)
+  local.get 0
+  local.get 1
+  local.get 2
+  local.get 3
+  array.init_elem $any-array $passive-2
+ )
+
  ;; CHECK:      (func $ref-as-non-null (type $8) (param $0 anyref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (ref.as_non_null
@@ -3739,7 +3833,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $52) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $58) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -3765,7 +3859,368 @@
   drop
  )
 
- ;; CHECK:      (func $call (type $20) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $string-new (type $59) (param $0 i32) (param $1 i32) (result stringref)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.new_utf8_try
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (local.get $1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.new_wtf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (local.get $1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.new_lossy_utf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (local.get $1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (string.new_wtf16
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-new (param i32 i32) (result stringref)
+  local.get 0
+  local.get 1
+  string.new_utf8_try
+  drop
+  local.get 0
+  local.get 1
+  string.new_wtf8 0
+  drop
+  local.get 0
+  local.get 1
+  string.new_lossy_utf8 $mem
+  drop
+  local.get 0
+  local.get 1
+  string.new_wtf16
+ )
+
+ ;; CHECK:      (func $string-new-gc (type $60) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
+ ;; CHECK-NEXT:  (string.new_utf8_array
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:   (local.get $2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-new-gc (param (ref $packed-i8) i32 i32) (result stringref)
+  local.get 0
+  local.get 1
+  local.get 2
+  string.new_utf8_array
+ )
+
+ ;; CHECK:      (func $string-new-code-point (type $61) (param $0 i32) (result stringref)
+ ;; CHECK-NEXT:  (string.from_code_point
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-new-code-point (param i32) (result stringref)
+  local.get 0
+  string.from_code_point
+ )
+
+ ;; CHECK:      (func $string-const (type $62) (result (ref string))
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.const "foobar")
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (string.const "\00\00\00")
+ ;; CHECK-NEXT: )
+ (func $string-const (result (ref string))
+  string.const "foobar"
+  drop
+  string.const "\00\00\00"
+ )
+
+ ;; CHECK:      (func $string-measure (type $21) (param $0 stringref)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.measure_wtf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.measure_utf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.measure_wtf16
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.is_usv_sequence
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-measure (param stringref)
+  local.get 0
+  string.measure_wtf8
+  drop
+  local.get 0
+  string.measure_utf8
+  drop
+  local.get 0
+  string.measure_wtf16
+  drop
+  local.get 0
+  string.is_usv_sequence
+  drop
+ )
+
+ ;; CHECK:      (func $string-hash (type $63) (param $0 stringref) (result i32)
+ ;; CHECK-NEXT:  (string.hash
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-hash (param stringref) (result i32)
+  local.get 0
+  string.hash
+ )
+
+ ;; CHECK:      (func $stringview-length (type $64) (param $0 stringview_wtf16) (result i32)
+ ;; CHECK-NEXT:  (stringview_wtf16.length
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $stringview-length (param stringview_wtf16) (result i32)
+  local.get 0
+  stringview_wtf16.length
+ )
+
+ ;; CHECK:      (func $string-encode (type $21) (param $0 stringref)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.encode_wtf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.encode_lossy_utf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.encode_utf8
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (i32.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (string.encode_wtf16
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (i32.const 3)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-encode (param stringref)
+  local.get 0
+  i32.const 0
+  string.encode_wtf8
+  drop
+  local.get 0
+  i32.const 1
+  string.encode_lossy_utf8 0
+  drop
+  local.get 0
+  i32.const 2
+  string.encode_utf8 $mem
+  drop
+  local.get 0
+  i32.const 3
+  string.encode_wtf16
+  drop
+ )
+
+ ;; CHECK:      (func $string-encode-gc (type $65) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
+ ;; CHECK-NEXT:  (string.encode_wtf8_array
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:   (local.get $2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-encode-gc (param stringref (ref $packed-i8) i32) (result i32)
+  local.get 0
+  local.get 1
+  local.get 2
+  string.encode_wtf8_array
+ )
+
+ ;; CHECK:      (func $string-concat (type $66) (param $0 stringref) (param $1 stringref) (result (ref string))
+ ;; CHECK-NEXT:  (string.concat
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-concat (param stringref stringref) (result (ref string))
+  local.get 0
+  local.get 1
+  string.concat
+ )
+
+ ;; CHECK:      (func $string-eq (type $22) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK-NEXT:  (string.eq
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-eq (param stringref stringref) (result i32)
+  local.get 0
+  local.get 1
+  string.eq
+ )
+
+ ;; CHECK:      (func $string-compare (type $22) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK-NEXT:  (string.compare
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-compare (param stringref stringref) (result i32)
+  local.get 0
+  local.get 1
+  string.compare
+ )
+
+ ;; CHECK:      (func $string-as-wtf8 (type $67) (param $0 stringref) (result stringview_wtf8)
+ ;; CHECK-NEXT:  (string.as_wtf8
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-as-wtf8 (param stringref) (result stringview_wtf8)
+  local.get 0
+  string.as_wtf8
+ )
+
+ ;; CHECK:      (func $string-as-wtf16 (type $68) (param $0 stringref) (result (ref stringview_wtf16))
+ ;; CHECK-NEXT:  (string.as_wtf16
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-as-wtf16 (param stringref) (result (ref stringview_wtf16))
+  local.get 0
+  string.as_wtf16
+ )
+
+ ;; CHECK:      (func $string-as-iter (type $69) (param $0 stringref) (result stringview_iter)
+ ;; CHECK-NEXT:  (string.as_iter
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-as-iter (param stringref) (result stringview_iter)
+  local.get 0
+  string.as_iter
+ )
+
+ ;; CHECK:      (func $string-advance (type $70) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
+ ;; CHECK-NEXT:  (stringview_wtf8.advance
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:   (local.get $2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-advance (param (ref stringview_wtf8) i32 i32) (result i32)
+  local.get 0
+  local.get 1
+  local.get 2
+  stringview_wtf8.advance
+ )
+
+ ;; CHECK:      (func $string-get (type $71) (param $0 stringview_wtf16) (param $1 i32) (result i32)
+ ;; CHECK-NEXT:  (stringview_wtf16.get_codeunit
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-get (param stringview_wtf16 i32) (result i32)
+  local.get 0
+  local.get 1
+  stringview_wtf16.get_codeunit
+ )
+
+ ;; CHECK:      (func $string-iter-next (type $72) (param $0 stringview_iter) (result i32)
+ ;; CHECK-NEXT:  (stringview_iter.next
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-iter-next (param stringview_iter) (result i32)
+  local.get 0
+  stringview_iter.next
+ )
+
+ ;; CHECK:      (func $string-iter-advance (type $73) (param $0 stringview_iter) (param $1 i32) (result i32)
+ ;; CHECK-NEXT:  (stringview_iter.advance
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-iter-advance (param (ref null stringview_iter) i32) (result i32)
+  local.get 0
+  local.get 1
+  stringview_iter.advance
+ )
+
+ ;; CHECK:      (func $string-iter-rewind (type $74) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
+ ;; CHECK-NEXT:  (stringview_iter.rewind
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-iter-rewind (param (ref stringview_iter) i32) (result i32)
+  local.get 0
+  local.get 1
+  stringview_iter.rewind
+ )
+
+ ;; CHECK:      (func $string-slice (type $75) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (stringview_wtf8.slice
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (local.get $2)
+ ;; CHECK-NEXT:    (local.get $3)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (stringview_wtf16.slice
+ ;; CHECK-NEXT:    (local.get $1)
+ ;; CHECK-NEXT:    (local.get $2)
+ ;; CHECK-NEXT:    (local.get $3)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-slice (param stringview_wtf8 stringview_wtf16 i32 i32)
+  local.get 0
+  local.get 2
+  local.get 3
+  stringview_wtf8.slice
+  drop
+  local.get 1
+  local.get 2
+  local.get 3
+  stringview_wtf16.slice
+  drop
+ )
+
+ ;; CHECK:      (func $string-iter-slice (type $76) (param $0 stringview_iter) (param $1 i32) (result (ref string))
+ ;; CHECK-NEXT:  (stringview_iter.slice
+ ;; CHECK-NEXT:   (local.get $0)
+ ;; CHECK-NEXT:   (local.get $1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $string-iter-slice (param stringview_iter i32) (result (ref string))
+  local.get 0
+  local.get 1
+  stringview_iter.slice
+ )
+
+ ;; CHECK:      (func $call (type $23) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (call $call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3777,7 +4232,7 @@
   call $call
  )
 
- ;; CHECK:      (func $return_call (type $20) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $return_call (type $23) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (return_call $return_call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3789,7 +4244,7 @@
   return_call $return_call
  )
 
- ;; CHECK:      (func $call-indirect (type $14) (param $0 i32) (param $1 i64) (param $2 v128)
+ ;; CHECK:      (func $call-indirect (type $16) (param $0 i32) (param $1 i64) (param $2 v128)
  ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3818,7 +4273,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $53)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $77)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -3851,7 +4306,7 @@
   drop
  )
 
- ;; CHECK:      (func $return-call-indirect (type $14) (param $0 i32) (param $1 i64) (param $2 v128)
+ ;; CHECK:      (func $return-call-indirect (type $16) (param $0 i32) (param $1 i64) (param $2 v128)
  ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3879,7 +4334,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $54)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $78)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -3910,7 +4365,7 @@
   return_call_indirect (param i64 v128)
  )
 
- ;; CHECK:      (func $use-types (type $65) (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 $89) (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