Implement changes in reference types proposal

This updates reference types proposal up-to-date, per
WebAssembly/reference-types#87.

Only maybe half of tests have been updated, so CI will not pass. I was
in the process of updating them fully, but I noticed WebAssembly#3084, so I'm not
sure if I continue to do this anymore. I asked him if he wanted to do it
himself to prevent this situation but apparently my questions weren't
answered and I didn't know that he was working on this at the same time.

I'm uploading this anyway in case this is necessary for discussions.

Author: aheejin

check.py

@@ -240,10 +240,7 @@ def check_expected(actual, expected):
         # some wast files cannot be split:
         #     * comments.wast: contains characters that are not valid utf-8,
         #       so our string splitting code fails there
-
-        # FIXME Remove reference type tests from this list after nullref is
-        # implemented in V8
-        if base not in ['comments.wast', 'ref_null.wast', 'ref_is_null.wast', 'ref_func.wast', 'old_select.wast']:
+        if base not in ['comments.wast', 'old_select.wast']:
             split_num = 0
             actual = ''
             for module, asserts in support.split_wast(wast):

scripts/gen-s-parser.py

@@ -50,7 +50,6 @@
     ("v128.pop",       "makePop(Type::v128)"),
     ("funcref.pop",    "makePop(Type::funcref)"),
     ("externref.pop",  "makePop(Type::externref)"),
-    ("nullref.pop",    "makePop(Type::nullref)"),
     ("exnref.pop",     "makePop(Type::exnref)"),
     ("i32.load",       "makeLoad(s, Type::i32, /*isAtomic=*/false)"),
     ("i64.load",       "makeLoad(s, Type::i64, /*isAtomic=*/false)"),

scripts/test/wasm_opt.py

@@ -113,10 +113,8 @@ def check():
 
         shared.fail_if_not_identical_to_file(actual, f)
 
-        # FIXME Remove this condition after nullref is implemented in V8
-        if 'reference-types.wast' not in t:
-            shared.binary_format_check(t, wasm_as_args=['-g'])  # test with debuginfo
-            shared.binary_format_check(t, wasm_as_args=[], binary_suffix='.fromBinary.noDebugInfo')  # test without debuginfo
+        shared.binary_format_check(t, wasm_as_args=['-g'])  # test with debuginfo
+        shared.binary_format_check(t, wasm_as_args=[], binary_suffix='.fromBinary.noDebugInfo')  # test without debuginfo
 
         shared.minify_check(t)
 

src/asmjs/asm_v_wasm.cpp

@@ -56,7 +56,6 @@ AsmType wasmToAsmType(Type type) {
       assert(false && "v128 not implemented yet");
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref:
       assert(false && "reference types are not supported by asm2wasm");
     case Type::none:
@@ -84,8 +83,6 @@ char getSig(Type type) {
       return 'F';
     case Type::externref:
       return 'X';
-    case Type::nullref:
-      return 'N';
     case Type::exnref:
       return 'E';
     case Type::none:

src/binaryen-c.cpp

@@ -71,8 +71,6 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
     case Type::funcref:
       ret.func = x.getFunc().c_str();
       break;
-    case Type::nullref:
-      break;
     case Type::externref:
     case Type::exnref:
     case Type::none:
@@ -96,8 +94,6 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
       return Literal(x.v128);
     case Type::funcref:
       return Literal::makeFuncref(x.func);
-    case Type::nullref:
-      return Literal::makeNullref();
     case Type::externref:
     case Type::exnref:
     case Type::none:
@@ -133,7 +129,6 @@ BinaryenType BinaryenTypeFloat64(void) { return Type::f64; }
 BinaryenType BinaryenTypeVec128(void) { return Type::v128; }
 BinaryenType BinaryenTypeFuncref(void) { return Type::funcref; }
 BinaryenType BinaryenTypeExternref(void) { return Type::externref; }
-BinaryenType BinaryenTypeNullref(void) { return Type::nullref; }
 BinaryenType BinaryenTypeExnref(void) { return Type::exnref; }
 BinaryenType BinaryenTypeUnreachable(void) { return Type::unreachable; }
 BinaryenType BinaryenTypeAuto(void) { return uintptr_t(-1); }
@@ -1264,8 +1259,10 @@ BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module, BinaryenType type) {
     Builder(*(Module*)module).makePop(Type(type)));
 }
 
-BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module) {
-  return static_cast<Expression*>(Builder(*(Module*)module).makeRefNull());
+BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module,
+                                      BinaryenType type) {
+  return static_cast<Expression*>(
+    Builder(*(Module*)module).makeRefNull(Type(type)));
 }
 
 BinaryenExpressionRef BinaryenRefIsNull(BinaryenModuleRef module,

src/binaryen-c.h

@@ -100,7 +100,6 @@ BINARYEN_API BinaryenType BinaryenTypeFloat64(void);
 BINARYEN_API BinaryenType BinaryenTypeVec128(void);
 BINARYEN_API BinaryenType BinaryenTypeFuncref(void);
 BINARYEN_API BinaryenType BinaryenTypeExternref(void);
-BINARYEN_API BinaryenType BinaryenTypeNullref(void);
 BINARYEN_API BinaryenType BinaryenTypeExnref(void);
 BINARYEN_API BinaryenType BinaryenTypeUnreachable(void);
 // Not a real type. Used as the last parameter to BinaryenBlock to let
@@ -826,7 +825,8 @@ BinaryenMemoryFill(BinaryenModuleRef module,
                    BinaryenExpressionRef dest,
                    BinaryenExpressionRef value,
                    BinaryenExpressionRef size);
-BINARYEN_API BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module);
+BINARYEN_API BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module,
+                                                   BinaryenType type);
 BINARYEN_API BinaryenExpressionRef
 BinaryenRefIsNull(BinaryenModuleRef module, BinaryenExpressionRef value);
 BINARYEN_API BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module,

src/gen-s-parser.inc

@@ -2560,17 +2560,9 @@ switch (op[0]) {
       default: goto parse_error;
     }
   }
-  case 'n': {
-    switch (op[1]) {
-      case 'o':
-        if (strcmp(op, "nop") == 0) { return makeNop(); }
-        goto parse_error;
-      case 'u':
-        if (strcmp(op, "nullref.pop") == 0) { return makePop(Type::nullref); }
-        goto parse_error;
-      default: goto parse_error;
-    }
-  }
+  case 'n':
+    if (strcmp(op, "nop") == 0) { return makeNop(); }
+    goto parse_error;
   case 'r': {
     switch (op[2]) {
       case 'f': {

src/ir/ExpressionManipulator.cpp

@@ -227,7 +227,9 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
         builder.makeHost(curr->op, curr->nameOperand, std::move(operands));
       return ret;
     }
-    Expression* visitRefNull(RefNull* curr) { return builder.makeRefNull(); }
+    Expression* visitRefNull(RefNull* curr) {
+      return builder.makeRefNull(curr->type);
+    }
     Expression* visitRefIsNull(RefIsNull* curr) {
       return builder.makeRefIsNull(copy(curr->value));
     }

src/ir/abstract.h

@@ -103,7 +103,6 @@ inline UnaryOp getUnary(Type type, Op op) {
     }
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref:
     case Type::none:
     case Type::unreachable: {
@@ -268,7 +267,6 @@ inline BinaryOp getBinary(Type type, Op op) {
     }
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref:
     case Type::none:
     case Type::unreachable: {

src/ir/properties.h

@@ -94,7 +94,7 @@ inline Literal getSingleLiteral(const Expression* curr) {
   if (auto* c = curr->dynCast<Const>()) {
     return c->value;
   } else if (curr->is<RefNull>()) {
-    return Literal(Type::nullref);
+    return Literal::makeNull(curr->type);
   } else if (auto* c = curr->dynCast<RefFunc>()) {
     return Literal(c->func);
   } else {