Implement extern.externalize and extern.internalize (#4975)

These new GC instructions infallibly convert between `extern` and `any`
references now that those types are not in the same hierarchy.

Author: tlively

CHANGELOG.md

@@ -29,6 +29,7 @@ Current Trunk
 - HeapType::ext has been restored but is no longer a subtype of HeapType::any to
   match the latest updates in the GC spec. (#4898)
 - `i31ref` and `dataref` are now nullable to match the latest GC spec. (#4843)
+- Add support for `extern.externalize` and `extern.internalize`. (#4975)
 
 v109
 ----

scripts/fuzz_opt.py

@@ -270,8 +270,10 @@ def is_git_repo():
 INITIAL_CONTENTS_IGNORE = [
     # not all relaxed SIMD instructions are implemented in the interpreter
     'relaxed-simd.wast',
-    # TODO fuzzer and interpreter support for strings
+    # TODO: fuzzer and interpreter support for strings
     'strings.wast',
+    # TODO: fuzzer and interpreter support for extern conversions
+    'extern-conversions.wast',
     # ignore DWARF because it is incompatible with multivalue atm
     'zlib.wasm',
     'cubescript.wasm',

scripts/gen-s-parser.py

@@ -604,6 +604,8 @@
     ("ref.as_func",          "makeRefAs(s, RefAsFunc)"),
     ("ref.as_data",          "makeRefAs(s, RefAsData)"),
     ("ref.as_i31",           "makeRefAs(s, RefAsI31)"),
+    ("extern.internalize",   "makeRefAs(s, ExternInternalize)"),
+    ("extern.externalize",   "makeRefAs(s, ExternExternalize)"),
     ("string.new_wtf8",      "makeStringNew(s, StringNewWTF8)"),
     ("string.new_wtf16",     "makeStringNew(s, StringNewWTF16)"),
     ("string.new_wtf8_array",  "makeStringNew(s, StringNewWTF8Array)"),

src/gen-s-parser.inc

@@ -185,9 +185,25 @@ switch (op[0]) {
       default: goto parse_error;
     }
   }
-  case 'e':
-    if (strcmp(op, "else") == 0) { return makeThenOrElse(s); }
-    goto parse_error;
+  case 'e': {
+    switch (op[1]) {
+      case 'l':
+        if (strcmp(op, "else") == 0) { return makeThenOrElse(s); }
+        goto parse_error;
+      case 'x': {
+        switch (op[7]) {
+          case 'e':
+            if (strcmp(op, "extern.externalize") == 0) { return makeRefAs(s, ExternExternalize); }
+            goto parse_error;
+          case 'i':
+            if (strcmp(op, "extern.internalize") == 0) { return makeRefAs(s, ExternInternalize); }
+            goto parse_error;
+          default: goto parse_error;
+        }
+      }
+      default: goto parse_error;
+    }
+  }
   case 'f': {
     switch (op[1]) {
       case '3': {
@@ -3816,13 +3832,37 @@ switch (op[0]) {
       default: goto parse_error;
     }
   }
-  case 'e':
-    if (op == "else"sv) {
-      auto ret = makeThenOrElse(ctx, in);
-      CHECK_ERR(ret);
-      return *ret;
+  case 'e': {
+    switch (op[1]) {
+      case 'l':
+        if (op == "else"sv) {
+          auto ret = makeThenOrElse(ctx, in);
+          CHECK_ERR(ret);
+          return *ret;
+        }
+        goto parse_error;
+      case 'x': {
+        switch (op[7]) {
+          case 'e':
+            if (op == "extern.externalize"sv) {
+              auto ret = makeRefAs(ctx, in, ExternExternalize);
+              CHECK_ERR(ret);
+              return *ret;
+            }
+            goto parse_error;
+          case 'i':
+            if (op == "extern.internalize"sv) {
+              auto ret = makeRefAs(ctx, in, ExternInternalize);
+              CHECK_ERR(ret);
+              return *ret;
+            }
+            goto parse_error;
+          default: goto parse_error;
+        }
+      }
+      default: goto parse_error;
     }
-    goto parse_error;
+  }
   case 'f': {
     switch (op[1]) {
       case '3': {

src/ir/effects.h

@@ -726,6 +726,10 @@ class EffectAnalyzer {
       parent.implicitTrap = true;
     }
     void visitRefAs(RefAs* curr) {
+      if (curr->op == ExternInternalize || curr->op == ExternExternalize) {
+        // These conversions are infallible.
+        return;
+      }
       // traps when the arg is not valid
       parent.implicitTrap = true;
       // Note: We could be more precise here and report the lack of a possible

src/passes/Print.cpp

@@ -2214,6 +2214,12 @@ struct PrintExpressionContents
       case RefAsI31:
         printMedium(o, "ref.as_i31");
         break;
+      case ExternInternalize:
+        printMedium(o, "extern.internalize");
+        break;
+      case ExternExternalize:
+        printMedium(o, "extern.externalize");
+        break;
       default:
         WASM_UNREACHABLE("invalid ref.is_*");
     }

src/wasm-binary.h

@@ -1125,6 +1125,8 @@ enum ASTNodes {
   BrOnNonFunc = 0x63,
   BrOnNonData = 0x64,
   BrOnNonI31 = 0x65,
+  ExternInternalize = 0x70,
+  ExternExternalize = 0x71,
   StringNewWTF8 = 0x80,
   StringNewWTF16 = 0x81,
   StringConst = 0x82,

src/wasm-interpreter.h

@@ -1874,6 +1874,9 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
           trap("not an i31");
         }
         break;
+      case ExternInternalize:
+      case ExternExternalize:
+        WASM_UNREACHABLE("unimplemented extern conversion");
       default:
         WASM_UNREACHABLE("unimplemented ref.as_*");
     }
@@ -2226,6 +2229,13 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   Flow visitStringSliceIter(StringSliceIter* curr) {
     return Flow(NONCONSTANT_FLOW);
   }
+  Flow visitRefAs(RefAs* curr) {
+    // TODO: Remove this once interpretation is implemented.
+    if (curr->op == ExternInternalize || curr->op == ExternExternalize) {
+      return Flow(NONCONSTANT_FLOW);
+    }
+    return ExpressionRunner<SubType>::visitRefAs(curr);
+  }
 
   void trap(const char* why) override { throw NonconstantException(); }
 

src/wasm.h

@@ -568,6 +568,8 @@ enum RefAsOp {
   RefAsFunc,
   RefAsData,
   RefAsI31,
+  ExternInternalize,
+  ExternExternalize,
 };
 
 enum BrOnOp {

src/wasm/wasm-binary.cpp

@@ -3978,7 +3978,9 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) {
       }
       if (opcode == BinaryConsts::RefAsFunc ||
           opcode == BinaryConsts::RefAsData ||
-          opcode == BinaryConsts::RefAsI31) {
+          opcode == BinaryConsts::RefAsI31 ||
+          opcode == BinaryConsts::ExternInternalize ||
+          opcode == BinaryConsts::ExternExternalize) {
         visitRefAs((curr = allocator.alloc<RefAs>())->cast<RefAs>(), opcode);
         break;
       }
@@ -7347,6 +7349,12 @@ void WasmBinaryBuilder::visitRefAs(RefAs* curr, uint8_t code) {
     case BinaryConsts::RefAsI31:
       curr->op = RefAsI31;
       break;
+    case BinaryConsts::ExternInternalize:
+      curr->op = ExternInternalize;
+      break;
+    case BinaryConsts::ExternExternalize:
+      curr->op = ExternExternalize;
+      break;
     default:
       WASM_UNREACHABLE("invalid code for ref.as_*");
   }
@@ -7356,6 +7364,7 @@ void WasmBinaryBuilder::visitRefAs(RefAs* curr, uint8_t code) {
   }
   curr->finalize();
 }
+
 void WasmBinaryBuilder::throwError(std::string text) {
   throw ParseException(text, 0, pos);
 }