[Strings] Adopt new instruction binary encoding (#5714)

See WebAssembly/stringref#46.

This format is already adopted by V8: https://chromium-review.googlesource.com/c/v8/v8/+/3892695.
The text format is left unchanged (see #5607 for a discussion on the subject).

I have also added support for string.encode_lossy_utf8 and
string.encode_lossy_utf8 array (by allowing the replace policy for
Binaryen's string.encode_wtf8 instruction).

10 files changed, 129 insertions, 118 deletions

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 03132b23a..f1a3048c3 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1038,11 +1038,13 @@ BinaryenOp BinaryenBrOnCast(void) { return BrOnCast; }
 BinaryenOp BinaryenBrOnCastFail(void) { return BrOnCastFail; };
 BinaryenOp BinaryenStringNewUTF8(void) { return StringNewUTF8; }
 BinaryenOp BinaryenStringNewWTF8(void) { return StringNewWTF8; }
-BinaryenOp BinaryenStringNewReplace(void) { return StringNewReplace; }
+BinaryenOp BinaryenStringNewLossyUTF8(void) { return StringNewLossyUTF8; }
 BinaryenOp BinaryenStringNewWTF16(void) { return StringNewWTF16; }
 BinaryenOp BinaryenStringNewUTF8Array(void) { return StringNewUTF8Array; }
 BinaryenOp BinaryenStringNewWTF8Array(void) { return StringNewWTF8Array; }
-BinaryenOp BinaryenStringNewReplaceArray(void) { return StringNewReplaceArray; }
+BinaryenOp BinaryenStringNewLossyUTF8Array(void) {
+  return StringNewLossyUTF8Array;
+}
 BinaryenOp BinaryenStringNewWTF16Array(void) { return StringNewWTF16Array; }
 BinaryenOp BinaryenStringNewFromCodePoint(void) {
   return StringNewFromCodePoint;
@@ -1055,9 +1057,13 @@ BinaryenOp BinaryenStringMeasureWTF16View(void) {
   return StringMeasureWTF16View;
 }
 BinaryenOp BinaryenStringEncodeUTF8(void) { return StringEncodeUTF8; }
+BinaryenOp BinaryenStringEncodeLossyUTF8(void) { return StringEncodeLossyUTF8; }
 BinaryenOp BinaryenStringEncodeWTF8(void) { return StringEncodeWTF8; }
 BinaryenOp BinaryenStringEncodeWTF16(void) { return StringEncodeWTF16; }
 BinaryenOp BinaryenStringEncodeUTF8Array(void) { return StringEncodeUTF8Array; }
+BinaryenOp BinaryenStringEncodeLossyUTF8Array(void) {
+  return StringEncodeLossyUTF8Array;
+}
 BinaryenOp BinaryenStringEncodeWTF8Array(void) { return StringEncodeWTF8Array; }
 BinaryenOp BinaryenStringEncodeWTF16Array(void) {
   return StringEncodeWTF16Array;
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index a199561f0..07c116aec 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -690,11 +690,11 @@ BINARYEN_API BinaryenOp BinaryenBrOnCast(void);
 BINARYEN_API BinaryenOp BinaryenBrOnCastFail(void);
 BINARYEN_API BinaryenOp BinaryenStringNewUTF8(void);
 BINARYEN_API BinaryenOp BinaryenStringNewWTF8(void);
-BINARYEN_API BinaryenOp BinaryenStringNewReplace(void);
+BINARYEN_API BinaryenOp BinaryenStringNewLossyUTF8(void);
 BINARYEN_API BinaryenOp BinaryenStringNewWTF16(void);
 BINARYEN_API BinaryenOp BinaryenStringNewUTF8Array(void);
 BINARYEN_API BinaryenOp BinaryenStringNewWTF8Array(void);
-BINARYEN_API BinaryenOp BinaryenStringNewReplaceArray(void);
+BINARYEN_API BinaryenOp BinaryenStringNewLossyUTF8Array(void);
 BINARYEN_API BinaryenOp BinaryenStringNewWTF16Array(void);
 BINARYEN_API BinaryenOp BinaryenStringNewFromCodePoint(void);
 BINARYEN_API BinaryenOp BinaryenStringMeasureUTF8(void);
@@ -703,9 +703,11 @@ BINARYEN_API BinaryenOp BinaryenStringMeasureWTF16(void);
 BINARYEN_API BinaryenOp BinaryenStringMeasureIsUSV(void);
 BINARYEN_API BinaryenOp BinaryenStringMeasureWTF16View(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeUTF8(void);
+BINARYEN_API BinaryenOp BinaryenStringEncodeLossyUTF8(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeWTF8(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeWTF16(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeUTF8Array(void);
+BINARYEN_API BinaryenOp BinaryenStringEncodeLossyUTF8Array(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeWTF8Array(void);
 BINARYEN_API BinaryenOp BinaryenStringEncodeWTF16Array(void);
 BINARYEN_API BinaryenOp BinaryenStringAsWTF8(void);
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 893ff2cae..b4987b12b 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -841,13 +841,13 @@ private:
       switch (curr->op) {
         case StringNewUTF8:
         case StringNewWTF8:
-        case StringNewReplace:
+        case StringNewLossyUTF8:
         case StringNewWTF16:
           parent.readsMemory = true;
           break;
         case StringNewUTF8Array:
         case StringNewWTF8Array:
-        case StringNewReplaceArray:
+        case StringNewLossyUTF8Array:
         case StringNewWTF16Array:
           parent.readsArray = true;
           break;
@@ -865,11 +865,13 @@ private:
       parent.implicitTrap = true;
       switch (curr->op) {
         case StringEncodeUTF8:
+        case StringEncodeLossyUTF8:
         case StringEncodeWTF8:
         case StringEncodeWTF16:
           parent.writesMemory = true;
           break;
         case StringEncodeUTF8Array:
+        case StringEncodeLossyUTF8Array:
         case StringEncodeWTF8Array:
         case StringEncodeWTF16Array:
           parent.writesArray = true;
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 1101c1aab..1cbecfaff 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -578,11 +578,11 @@ function initializeConstants() {
     'BrOnCastFail',
     'StringNewUTF8',
     'StringNewWTF8',
-    'StringNewReplace',
+    'StringNewLossyUTF8',
     'StringNewWTF16',
     'StringNewUTF8Array',
     'StringNewWTF8Array',
-    'StringNewReplaceArray',
+    'StringNewLossyUTF8Array',
     'StringNewWTF16Array',
     'StringNewFromCodePoint',
     'StringMeasureUTF8',
@@ -591,9 +591,11 @@ function initializeConstants() {
     'StringMeasureIsUSV',
     'StringMeasureWTF16View',
     'StringEncodeUTF8',
+    'StringEncodeLossyUTF8',
     'StringEncodeWTF8',
     'StringEncodeWTF16',
     'StringEncodeUTF8Array',
+    'StringEncodeLossyUTF8Array',
     'StringEncodeWTF8Array',
     'StringEncodeWTF16Array',
     'StringAsWTF8',
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 0bddd338b..2ebf73638 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2375,7 +2375,7 @@ struct PrintExpressionContents
       case StringNewWTF8:
         printMedium(o, "string.new_wtf8 wtf8");
         break;
-      case StringNewReplace:
+      case StringNewLossyUTF8:
         printMedium(o, "string.new_wtf8 replace");
         break;
       case StringNewWTF16:
@@ -2391,7 +2391,7 @@ struct PrintExpressionContents
       case StringNewWTF8Array:
         printMedium(o, "string.new_wtf8_array wtf8");
         break;
-      case StringNewReplaceArray:
+      case StringNewLossyUTF8Array:
         printMedium(o, "string.new_wtf8_array replace");
         break;
       case StringNewWTF16Array:
@@ -2437,6 +2437,9 @@ struct PrintExpressionContents
       case StringEncodeUTF8:
         printMedium(o, "string.encode_wtf8 utf8");
         break;
+      case StringEncodeLossyUTF8:
+        printMedium(o, "string.encode_wtf8 replace");
+        break;
       case StringEncodeWTF8:
         printMedium(o, "string.encode_wtf8 wtf8");
         break;
@@ -2446,6 +2449,9 @@ struct PrintExpressionContents
       case StringEncodeUTF8Array:
         printMedium(o, "string.encode_wtf8_array utf8");
         break;
+      case StringEncodeLossyUTF8Array:
+        printMedium(o, "string.encode_wtf8_array replace");
+        break;
       case StringEncodeWTF8Array:
         printMedium(o, "string.encode_wtf8_array wtf8");
         break;
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 395044c4d..d1b7b4923 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1141,16 +1141,21 @@ enum ASTNodes {
   ArrayFill = 0x0f,
   ArrayInitData = 0x54,
   ArrayInitElem = 0x55,
-  StringNewWTF8 = 0x80,
+  StringNewUTF8 = 0x80,
   StringNewWTF16 = 0x81,
   StringConst = 0x82,
+  StringMeasureUTF8 = 0x83,
   StringMeasureWTF8 = 0x84,
   StringMeasureWTF16 = 0x85,
-  StringEncodeWTF8 = 0x86,
+  StringEncodeUTF8 = 0x86,
   StringEncodeWTF16 = 0x87,
   StringConcat = 0x88,
   StringEq = 0x89,
   StringIsUSV = 0x8a,
+  StringNewLossyUTF8 = 0x8b,
+  StringNewWTF8 = 0x8c,
+  StringEncodeLossyUTF8 = 0x8d,
+  StringEncodeWTF8 = 0x8e,
   StringNewUTF8Try = 0x8f,
   StringAsWTF8 = 0x90,
   StringViewWTF8Advance = 0x91,
@@ -1167,10 +1172,14 @@ enum ASTNodes {
   StringCompare = 0xa8,
   StringFromCodePoint = 0xa9,
   StringHash = 0xaa,
-  StringNewWTF8Array = 0xb0,
+  StringNewUTF8Array = 0xb0,
   StringNewWTF16Array = 0xb1,
-  StringEncodeWTF8Array = 0xb2,
+  StringEncodeUTF8Array = 0xb2,
   StringEncodeWTF16Array = 0xb3,
+  StringNewLossyUTF8Array = 0xb4,
+  StringNewWTF8Array = 0xb5,
+  StringEncodeLossyUTF8Array = 0xb6,
+  StringEncodeWTF8Array = 0xb7,
   StringNewUTF8ArrayTry = 0xb8,
 };
 
@@ -1182,12 +1191,6 @@ enum MemoryAccess {
 
 enum MemoryFlags { HasMaximum = 1 << 0, IsShared = 1 << 1, Is64 = 1 << 2 };
 
-enum StringPolicy {
-  UTF8 = 0x00,
-  WTF8 = 0x01,
-  Replace = 0x02,
-};
-
 enum FeaturePrefix {
   FeatureUsed = '+',
   FeatureRequired = '=',
diff --git a/src/wasm.h b/src/wasm.h
index 727c9ca30..afb824bdd 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -574,12 +574,12 @@ enum StringNewOp {
   // Linear memory
   StringNewUTF8,
   StringNewWTF8,
-  StringNewReplace,
+  StringNewLossyUTF8,
   StringNewWTF16,
   // GC
   StringNewUTF8Array,
   StringNewWTF8Array,
-  StringNewReplaceArray,
+  StringNewLossyUTF8Array,
   StringNewWTF16Array,
   // Other
   StringNewFromCodePoint,
@@ -596,9 +596,11 @@ enum StringMeasureOp {
 
 enum StringEncodeOp {
   StringEncodeUTF8,
+  StringEncodeLossyUTF8,
   StringEncodeWTF8,
   StringEncodeWTF16,
   StringEncodeUTF8Array,
+  StringEncodeLossyUTF8Array,
   StringEncodeWTF8Array,
   StringEncodeWTF16Array,
 };
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index 981932470..91309c906 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -7313,29 +7313,34 @@ bool WasmBinaryBuilder::maybeVisitStringNew(Expression*& out, uint32_t code) {
   Expression* start = nullptr;
   Expression* end = nullptr;
   bool try_ = false;
-  if (code == BinaryConsts::StringNewWTF8 ||
-      code == BinaryConsts::StringNewUTF8Try) {
-    if (code == BinaryConsts::StringNewUTF8Try) {
-      try_ = true;
+  if (code == BinaryConsts::StringNewUTF8) {
+    // FIXME: the memory index should be an LEB like all other places
+    if (getInt8() != 0) {
+      throwError("Unexpected nonzero memory index");
     }
+    op = StringNewUTF8;
+    length = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewLossyUTF8) {
     // FIXME: the memory index should be an LEB like all other places
     if (getInt8() != 0) {
       throwError("Unexpected nonzero memory index");
     }
-    auto policy = getU32LEB();
-    switch (policy) {
-      case BinaryConsts::StringPolicy::UTF8:
-        op = StringNewUTF8;
-        break;
-      case BinaryConsts::StringPolicy::WTF8:
-        op = StringNewWTF8;
-        break;
-      case BinaryConsts::StringPolicy::Replace:
-        op = StringNewReplace;
-        break;
-      default:
-        throwError("bad policy for string.new");
+    op = StringNewLossyUTF8;
+    length = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewWTF8) {
+    // FIXME: the memory index should be an LEB like all other places
+    if (getInt8() != 0) {
+      throwError("Unexpected nonzero memory index");
     }
+    op = StringNewWTF8;
+    length = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewUTF8Try) {
+    // FIXME: the memory index should be an LEB like all other places
+    if (getInt8() != 0) {
+      throwError("Unexpected nonzero memory index");
+    }
+    op = StringNewUTF8;
+    try_ = true;
     length = popNonVoidExpression();
   } else if (code == BinaryConsts::StringNewWTF16) {
     if (getInt8() != 0) {
@@ -7343,25 +7348,21 @@ bool WasmBinaryBuilder::maybeVisitStringNew(Expression*& out, uint32_t code) {
     }
     op = StringNewWTF16;
     length = popNonVoidExpression();
-  } else if (code == BinaryConsts::StringNewWTF8Array ||
-             code == BinaryConsts::StringNewUTF8ArrayTry) {
-    if (code == BinaryConsts::StringNewUTF8ArrayTry) {
-      try_ = true;
-    }
-    auto policy = getU32LEB();
-    switch (policy) {
-      case BinaryConsts::StringPolicy::UTF8:
-        op = StringNewUTF8Array;
-        break;
-      case BinaryConsts::StringPolicy::WTF8:
-        op = StringNewWTF8Array;
-        break;
-      case BinaryConsts::StringPolicy::Replace:
-        op = StringNewReplaceArray;
-        break;
-      default:
-        throwError("bad policy for string.new");
-    }
+  } else if (code == BinaryConsts::StringNewUTF8Array) {
+    op = StringNewUTF8Array;
+    end = popNonVoidExpression();
+    start = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewLossyUTF8Array) {
+    op = StringNewLossyUTF8Array;
+    end = popNonVoidExpression();
+    start = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewWTF8Array) {
+    op = StringNewWTF8Array;
+    end = popNonVoidExpression();
+    start = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringNewUTF8ArrayTry) {
+    op = StringNewUTF8Array;
+    try_ = true;
     end = popNonVoidExpression();
     start = popNonVoidExpression();
   } else if (code == BinaryConsts::StringNewWTF16Array) {
@@ -7397,18 +7398,10 @@ bool WasmBinaryBuilder::maybeVisitStringConst(Expression*& out, uint32_t code) {
 bool WasmBinaryBuilder::maybeVisitStringMeasure(Expression*& out,
                                                 uint32_t code) {
   StringMeasureOp op;
-  if (code == BinaryConsts::StringMeasureWTF8) {
-    auto policy = getU32LEB();
-    switch (policy) {
-      case BinaryConsts::StringPolicy::UTF8:
-        op = StringMeasureUTF8;
-        break;
-      case BinaryConsts::StringPolicy::WTF8:
-        op = StringMeasureWTF8;
-        break;
-      default:
-        throwError("bad policy for string.measure");
-    }
+  if (code == BinaryConsts::StringMeasureUTF8) {
+    op = StringMeasureUTF8;
+  } else if (code == BinaryConsts::StringMeasureWTF8) {
+    op = StringMeasureWTF8;
   } else if (code == BinaryConsts::StringMeasureWTF16) {
     op = StringMeasureWTF16;
   } else if (code == BinaryConsts::StringIsUSV) {
@@ -7430,38 +7423,34 @@ bool WasmBinaryBuilder::maybeVisitStringEncode(Expression*& out,
   StringEncodeOp op;
   Expression* start = nullptr;
   // TODO: share this code with string.measure?
-  if (code == BinaryConsts::StringEncodeWTF8) {
+  if (code == BinaryConsts::StringEncodeUTF8) {
     if (getInt8() != 0) {
       throwError("Unexpected nonzero memory index");
     }
-    auto policy = getU32LEB();
-    switch (policy) {
-      case BinaryConsts::StringPolicy::UTF8:
-        op = StringEncodeUTF8;
-        break;
-      case BinaryConsts::StringPolicy::WTF8:
-        op = StringEncodeWTF8;
-        break;
-      default:
-        throwError("bad policy for string.encode");
+    op = StringEncodeUTF8;
+  } else if (code == BinaryConsts::StringEncodeLossyUTF8) {
+    if (getInt8() != 0) {
+      throwError("Unexpected nonzero memory index");
+    }
+    op = StringEncodeLossyUTF8;
+  } else if (code == BinaryConsts::StringEncodeWTF8) {
+    if (getInt8() != 0) {
+      throwError("Unexpected nonzero memory index");
     }
+    op = StringEncodeWTF8;
   } else if (code == BinaryConsts::StringEncodeWTF16) {
     if (getInt8() != 0) {
       throwError("Unexpected nonzero memory index");
     }
     op = StringEncodeWTF16;
+  } else if (code == BinaryConsts::StringEncodeUTF8Array) {
+    op = StringEncodeUTF8Array;
+    start = popNonVoidExpression();
+  } else if (code == BinaryConsts::StringEncodeLossyUTF8Array) {
+    op = StringEncodeLossyUTF8Array;
+    start = popNonVoidExpression();
   } else if (code == BinaryConsts::StringEncodeWTF8Array) {
-    auto policy = getU32LEB();
-    switch (policy) {
-      case BinaryConsts::StringPolicy::UTF8:
-        op = StringEncodeUTF8Array;
-        break;
-      case BinaryConsts::StringPolicy::WTF8:
-        op = StringEncodeWTF8Array;
-        break;
-      default:
-        throwError("bad policy for string.encode");
-    }
+    op = StringEncodeWTF8Array;
     start = popNonVoidExpression();
   } else if (code == BinaryConsts::StringEncodeWTF16Array) {
     op = StringEncodeWTF16Array;
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 44008bb75..6adfb6149 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -3099,7 +3099,7 @@ SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
       } else if (str == "wtf8") {
         op = StringNewWTF8;
       } else if (str == "replace") {
-        op = StringNewReplace;
+        op = StringNewLossyUTF8;
       } else {
         throw ParseException("bad string.new op", s.line, s.col);
       }
@@ -3117,7 +3117,7 @@ SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
       } else if (str == "wtf8") {
         op = StringNewWTF8Array;
       } else if (str == "replace") {
-        op = StringNewReplaceArray;
+        op = StringNewLossyUTF8Array;
       } else {
         throw ParseException("bad string.new op", s.line, s.col);
       }
@@ -3170,6 +3170,8 @@ Expression* SExpressionWasmBuilder::makeStringEncode(Element& s,
     std::string_view str = s[i++]->str().str;
     if (str == "utf8") {
       op = StringEncodeUTF8;
+    } else if (str == "replace") {
+      op = StringEncodeLossyUTF8;
     } else if (str == "wtf8") {
       op = StringEncodeWTF8;
     } else {
@@ -3179,6 +3181,8 @@ Expression* SExpressionWasmBuilder::makeStringEncode(Element& s,
     std::string_view str = s[i++]->str().str;
     if (str == "utf8") {
       op = StringEncodeUTF8Array;
+    } else if (str == "replace") {
+      op = StringEncodeLossyUTF8Array;
     } else if (str == "wtf8") {
       op = StringEncodeWTF8Array;
     } else {
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 14c24d807..7a4dd3983 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2235,22 +2235,19 @@ void BinaryInstWriter::visitStringNew(StringNew* curr) {
   switch (curr->op) {
     case StringNewUTF8:
       if (!curr->try_) {
-        o << U32LEB(BinaryConsts::StringNewWTF8);
+        o << U32LEB(BinaryConsts::StringNewUTF8);
       } else {
         o << U32LEB(BinaryConsts::StringNewUTF8Try);
       }
       o << int8_t(0); // Memory index.
-      o << U32LEB(BinaryConsts::StringPolicy::UTF8);
       break;
     case StringNewWTF8:
       o << U32LEB(BinaryConsts::StringNewWTF8);
       o << int8_t(0); // Memory index.
-      o << U32LEB(BinaryConsts::StringPolicy::WTF8);
       break;
-    case StringNewReplace:
-      o << U32LEB(BinaryConsts::StringNewWTF8);
+    case StringNewLossyUTF8:
+      o << U32LEB(BinaryConsts::StringNewLossyUTF8);
       o << int8_t(0); // Memory index.
-      o << U32LEB(BinaryConsts::StringPolicy::Replace);
       break;
     case StringNewWTF16:
       o << U32LEB(BinaryConsts::StringNewWTF16);
@@ -2258,19 +2255,16 @@ void BinaryInstWriter::visitStringNew(StringNew* curr) {
       break;
     case StringNewUTF8Array:
       if (!curr->try_) {
-        o << U32LEB(BinaryConsts::StringNewWTF8Array);
+        o << U32LEB(BinaryConsts::StringNewUTF8Array);
       } else {
         o << U32LEB(BinaryConsts::StringNewUTF8ArrayTry);
       }
-      o << U32LEB(BinaryConsts::StringPolicy::UTF8);
       break;
     case StringNewWTF8Array:
-      o << U32LEB(BinaryConsts::StringNewWTF8Array)
-        << U32LEB(BinaryConsts::StringPolicy::WTF8);
+      o << U32LEB(BinaryConsts::StringNewWTF8Array);
       break;
-    case StringNewReplaceArray:
-      o << U32LEB(BinaryConsts::StringNewWTF8Array)
-        << U32LEB(BinaryConsts::StringPolicy::Replace);
+    case StringNewLossyUTF8Array:
+      o << U32LEB(BinaryConsts::StringNewLossyUTF8Array);
       break;
     case StringNewWTF16Array:
       o << U32LEB(BinaryConsts::StringNewWTF16Array);
@@ -2292,12 +2286,10 @@ void BinaryInstWriter::visitStringMeasure(StringMeasure* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
   switch (curr->op) {
     case StringMeasureUTF8:
-      o << U32LEB(BinaryConsts::StringMeasureWTF8)
-        << U32LEB(BinaryConsts::StringPolicy::UTF8);
+      o << U32LEB(BinaryConsts::StringMeasureUTF8);
       break;
     case StringMeasureWTF8:
-      o << U32LEB(BinaryConsts::StringMeasureWTF8)
-        << U32LEB(BinaryConsts::StringPolicy::WTF8);
+      o << U32LEB(BinaryConsts::StringMeasureWTF8);
       break;
     case StringMeasureWTF16:
       o << U32LEB(BinaryConsts::StringMeasureWTF16);
@@ -2320,26 +2312,29 @@ void BinaryInstWriter::visitStringEncode(StringEncode* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
   switch (curr->op) {
     case StringEncodeUTF8:
-      o << U32LEB(BinaryConsts::StringEncodeWTF8);
+      o << U32LEB(BinaryConsts::StringEncodeUTF8);
+      o << int8_t(0); // Memory index.
+      break;
+    case StringEncodeLossyUTF8:
+      o << U32LEB(BinaryConsts::StringEncodeLossyUTF8);
       o << int8_t(0); // Memory index.
-      o << U32LEB(BinaryConsts::StringPolicy::UTF8);
       break;
     case StringEncodeWTF8:
       o << U32LEB(BinaryConsts::StringEncodeWTF8);
       o << int8_t(0); // Memory index.
-      o << U32LEB(BinaryConsts::StringPolicy::WTF8);
       break;
     case StringEncodeWTF16:
       o << U32LEB(BinaryConsts::StringEncodeWTF16);
       o << int8_t(0); // Memory index.
       break;
     case StringEncodeUTF8Array:
-      o << U32LEB(BinaryConsts::StringEncodeWTF8Array);
-      o << U32LEB(BinaryConsts::StringPolicy::UTF8);
+      o << U32LEB(BinaryConsts::StringEncodeUTF8Array);
+      break;
+    case StringEncodeLossyUTF8Array:
+      o << U32LEB(BinaryConsts::StringEncodeLossyUTF8Array);
       break;
     case StringEncodeWTF8Array:
-      o << U32LEB(BinaryConsts::StringEncodeWTF8Array)
-        << U32LEB(BinaryConsts::StringPolicy::WTF8);
+      o << U32LEB(BinaryConsts::StringEncodeWTF8Array);
       break;
     case StringEncodeWTF16Array:
       o << U32LEB(BinaryConsts::StringEncodeWTF16Array);