Add ref.cast_nop_static (#4656)

This unsafe experimental instruction is semantically equivalent to
ref.cast_static, but V8 will unsafely turn it into a nop. This is meant to help
us measure cast overhead more precisely than we can by globally turning all
casts into nops.

Author: tlively

scripts/gen-s-parser.py

@@ -573,6 +573,7 @@
     ("ref.test_static",      "makeRefTestStatic(s)"),
     ("ref.cast",             "makeRefCast(s)"),
     ("ref.cast_static",      "makeRefCastStatic(s)"),
+    ("ref.cast_nop_static",  "makeRefCastNopStatic(s)"),
     ("br_on_null",           "makeBrOn(s, BrOnNull)"),
     ("br_on_non_null",       "makeBrOn(s, BrOnNonNull)"),
     ("br_on_cast",           "makeBrOn(s, BrOnCast)"),

src/gen-s-parser.inc

@@ -3027,9 +3027,17 @@ switch (op[0]) {
                   case '\0':
                     if (strcmp(op, "ref.cast") == 0) { return makeRefCast(s); }
                     goto parse_error;
-                  case '_':
-                    if (strcmp(op, "ref.cast_static") == 0) { return makeRefCastStatic(s); }
-                    goto parse_error;
+                  case '_': {
+                    switch (op[9]) {
+                      case 'n':
+                        if (strcmp(op, "ref.cast_nop_static") == 0) { return makeRefCastNopStatic(s); }
+                        goto parse_error;
+                      case 's':
+                        if (strcmp(op, "ref.cast_static") == 0) { return makeRefCastStatic(s); }
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
                   default: goto parse_error;
                 }
               }

src/passes/Print.cpp

@@ -1984,7 +1984,11 @@ struct PrintExpressionContents
     if (curr->rtt) {
       printMedium(o, "ref.cast");
     } else {
-      printMedium(o, "ref.cast_static ");
+      if (curr->safety == RefCast::Unsafe) {
+        printMedium(o, "ref.cast_nop_static ");
+      } else {
+        printMedium(o, "ref.cast_static ");
+      }
       printHeapType(o, curr->intendedType, wasm);
     }
   }

src/wasm-binary.h

@@ -1112,6 +1112,7 @@ enum ASTNodes {
   RefCastStatic = 0x45,
   BrOnCastStatic = 0x46,
   BrOnCastStaticFail = 0x47,
+  RefCastNopStatic = 0x48,
   RefIsFunc = 0x50,
   RefIsData = 0x51,
   RefIsI31 = 0x52,

src/wasm-builder.h

@@ -810,10 +810,13 @@ class Builder {
     ret->finalize();
     return ret;
   }
-  RefCast* makeRefCast(Expression* ref, HeapType intendedType) {
+
+  RefCast*
+  makeRefCast(Expression* ref, HeapType intendedType, RefCast::Safety safety) {
     auto* ret = wasm.allocator.alloc<RefCast>();
     ret->ref = ref;
     ret->intendedType = intendedType;
+    ret->safety = safety;
     ret->finalize();
     return ret;
   }

src/wasm-s-parser.h

@@ -282,6 +282,7 @@ class SExpressionWasmBuilder {
   Expression* makeRefTestStatic(Element& s);
   Expression* makeRefCast(Element& s);
   Expression* makeRefCastStatic(Element& s);
+  Expression* makeRefCastNopStatic(Element& s);
   Expression* makeBrOn(Element& s, BrOnOp op);
   Expression* makeBrOnStatic(Element& s, BrOnOp op);
   Expression* makeRttCanon(Element& s);

src/wasm.h

@@ -1457,6 +1457,11 @@ class RefCast : public SpecificExpression<Expression::RefCastId> {
   Expression* rtt = nullptr;
   HeapType intendedType;
 
+  // Support the unsafe `ref.cast_nop_static` to enable precise cast overhead
+  // measurements.
+  enum Safety { Safe, Unsafe };
+  Safety safety;
+
   void finalize();
 
   // Returns the type we intend to cast to.

src/wasm/wasm-binary.cpp

@@ -6712,10 +6712,13 @@ bool WasmBinaryBuilder::maybeVisitRefCast(Expression*& out, uint32_t code) {
     auto* ref = popNonVoidExpression();
     out = Builder(wasm).makeRefCast(ref, rtt);
     return true;
-  } else if (code == BinaryConsts::RefCastStatic) {
+  } else if (code == BinaryConsts::RefCastStatic ||
+             code == BinaryConsts::RefCastNopStatic) {
     auto intendedType = getIndexedHeapType();
     auto* ref = popNonVoidExpression();
-    out = Builder(wasm).makeRefCast(ref, intendedType);
+    auto safety =
+      code == BinaryConsts::RefCastNopStatic ? RefCast::Unsafe : RefCast::Safe;
+    out = Builder(wasm).makeRefCast(ref, intendedType, safety);
     return true;
   }
   return false;

src/wasm/wasm-s-parser.cpp

@@ -2702,7 +2702,13 @@ Expression* SExpressionWasmBuilder::makeRefCast(Element& s) {
 Expression* SExpressionWasmBuilder::makeRefCastStatic(Element& s) {
   auto heapType = parseHeapType(*s[1]);
   auto* ref = parseExpression(*s[2]);
-  return Builder(wasm).makeRefCast(ref, heapType);
+  return Builder(wasm).makeRefCast(ref, heapType, RefCast::Safe);
+}
+
+Expression* SExpressionWasmBuilder::makeRefCastNopStatic(Element& s) {
+  auto heapType = parseHeapType(*s[1]);
+  auto* ref = parseExpression(*s[2]);
+  return Builder(wasm).makeRefCast(ref, heapType, RefCast::Unsafe);
 }
 
 Expression* SExpressionWasmBuilder::makeBrOn(Element& s, BrOnOp op) {

src/wasm/wasm-stack.cpp

@@ -2051,7 +2051,11 @@ void BinaryInstWriter::visitRefCast(RefCast* curr) {
   if (curr->rtt) {
     o << U32LEB(BinaryConsts::RefCast);
   } else {
-    o << U32LEB(BinaryConsts::RefCastStatic);
+    if (curr->safety == RefCast::Unsafe) {
+      o << U32LEB(BinaryConsts::RefCastNopStatic);
+    } else {
+      o << U32LEB(BinaryConsts::RefCastStatic);
+    }
     parent.writeIndexedHeapType(curr->intendedType);
   }
 }