Update reference types

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)"),

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

@@ -69,12 +69,12 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
       memcpy(&ret.v128, x.getv128Ptr(), 16);
       break;
     case Type::funcref:
-      ret.func = x.getFunc().c_str();
-      break;
-    case Type::nullref:
+      ret.func = x.isNull() ? nullptr : x.getFunc().c_str();
       break;
     case Type::externref:
     case Type::exnref:
+      assert(x.isNull());
+      break;
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE("unexpected type");
@@ -95,11 +95,10 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
     case Type::v128:
       return Literal(x.v128);
     case Type::funcref:
-      return Literal::makeFuncref(x.func);
-    case Type::nullref:
-      return Literal::makeNullref();
+      return Literal::makeFunc(x.func);
     case Type::externref:
     case Type::exnref:
+      return Literal::makeNull(Type(x.type));
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE("unexpected type");
@@ -133,7 +132,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 +1262,11 @@ 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) {
+  Type type_(type);
+  assert(type_.isNullable());
+  return static_cast<Expression*>(Builder(*(Module*)module).makeRefNull(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/manipulation.h

@@ -40,9 +40,10 @@ template<typename InputType> inline Nop* nop(InputType* target) {
   return ret;
 }
 
-template<typename InputType> inline RefNull* refNull(InputType* target) {
+template<typename InputType>
+inline RefNull* refNull(InputType* target, Type type) {
   auto* ret = convert<InputType, RefNull>(target);
-  ret->finalize();
+  ret->finalize(type);
   return ret;
 }
 

src/ir/properties.h

@@ -93,10 +93,10 @@ inline bool isConstantExpression(const Expression* curr) {
 inline Literal getSingleLiteral(const Expression* curr) {
   if (auto* c = curr->dynCast<Const>()) {
     return c->value;
-  } else if (curr->is<RefNull>()) {
-    return Literal(Type::nullref);
-  } else if (auto* c = curr->dynCast<RefFunc>()) {
-    return Literal(c->func);
+  } else if (auto* n = curr->dynCast<RefNull>()) {
+    return Literal(n->type);
+  } else if (auto* r = curr->dynCast<RefFunc>()) {
+    return Literal(r->func);
   } else {
     WASM_UNREACHABLE("non-constant expression");
   }

src/js/binaryen.js-post.js

@@ -35,7 +35,6 @@ function initializeConstants() {
     ['v128', 'Vec128'],
     ['funcref', 'Funcref'],
     ['externref', 'Externref'],
-    ['nullref', 'Nullref'],
     ['exnref', 'Exnref'],
     ['unreachable', 'Unreachable'],
     ['auto', 'Auto']
@@ -2058,21 +2057,15 @@ function wrapModule(module, self = {}) {
     }
   };
 
-  self['nullref'] = {
-    'pop'() {
-      return Module['_BinaryenPop'](module, Module['nullref']);
-    }
-  };
-
   self['exnref'] = {
     'pop'() {
       return Module['_BinaryenPop'](module, Module['exnref']);
     }
   };
 
   self['ref'] = {
-    'null'() {
-      return Module['_BinaryenRefNull'](module);
+    'null'(type) {
+      return Module['_BinaryenRefNull'](module, type);
     },
     'is_null'(value) {
       return Module['_BinaryenRefIsNull'](module, value);

src/literal.h

@@ -39,19 +39,22 @@ class Literal {
     int32_t i32;
     int64_t i64;
     uint8_t v128[16];
-    Name func; // function name for funcref
+    // funcref function name. `isNull()` indicates a `null` value.
+    Name func;
+    // exnref package. `nullptr` indicates a `null` value.
     std::unique_ptr<ExceptionPackage> exn;
+    // TODO: Literals of type `externref` can only be `null` currently but we
+    // will need to represent extern values eventually, to
+    // 1) run the spec tests and fuzzer with reference types enabled and
+    // 2) avoid bailing out when seeing a reference typed value in precompute
   };
 
 public:
   // Type of the literal. Immutable because the literal's payload depends on it.
   const Type type;
 
   Literal() : v128(), type(Type::none) {}
-  explicit Literal(Type type) : v128(), type(type) {
-    assert(type != Type::unreachable && type != Type::funcref &&
-           type != Type::exnref);
-  }
+  explicit Literal(Type type);
   explicit Literal(Type::BasicID typeId) : Literal(Type(typeId)) {}
   explicit Literal(int32_t init) : i32(init), type(Type::i32) {}
   explicit Literal(uint32_t init) : i32(init), type(Type::i32) {}
@@ -74,13 +77,25 @@ class Literal {
   Literal(const Literal& other);
   Literal& operator=(const Literal& other);
   ~Literal() {
-    if (type == Type::exnref) {
+    if (type.isException()) {
       exn.~unique_ptr();
     }
   }
 
   bool isConcrete() const { return type != Type::none; }
   bool isNone() const { return type == Type::none; }
+  bool isNull() const {
+    if (type.isNullable()) {
+      if (type.isFunction()) {
+        return func.isNull();
+      }
+      if (type.isException()) {
+        return !exn;
+      }
+      return true;
+    }
+    return false;
+  }
 
   static Literal makeFromInt32(int32_t x, Type type) {
     switch (type.getBasic()) {
@@ -105,9 +120,12 @@ class Literal {
   static Literals makeZero(Type type);
   static Literal makeSingleZero(Type type);
 
-  static Literal makeNullref() { return Literal(Type(Type::nullref)); }
-  static Literal makeFuncref(Name func) { return Literal(func.c_str()); }
-  static Literal makeExnref(std::unique_ptr<ExceptionPackage>&& exn) {
+  static Literal makeNull(Type type) {
+    assert(type.isNullable());
+    return Literal(type);
+  }
+  static Literal makeFunc(Name func) { return Literal(func.c_str()); }
+  static Literal makeExn(std::unique_ptr<ExceptionPackage>&& exn) {
     return Literal(std::move(exn));
   }
 
@@ -134,7 +152,7 @@ class Literal {
   }
   std::array<uint8_t, 16> getv128() const;
   Name getFunc() const {
-    assert(type == Type::funcref);
+    assert(type.isFunction() && !func.isNull());
     return func;
   }
   ExceptionPackage getExceptionPackage() const;
@@ -502,6 +520,12 @@ class Literals : public SmallVector<Literal, 1> {
 struct ExceptionPackage {
   Name event;
   Literals values;
+  bool operator==(const ExceptionPackage& other) const {
+    return event == other.event && values == other.values;
+  }
+  bool operator!=(const ExceptionPackage& other) const {
+    return !(*this == other);
+  }
 };
 
 std::ostream& operator<<(std::ostream& o, wasm::Literal literal);
@@ -554,7 +578,6 @@ template<> struct less<wasm::Literal> {
         return memcmp(a.getv128Ptr(), b.getv128Ptr(), 16) < 0;
       case wasm::Type::funcref:
       case wasm::Type::externref:
-      case wasm::Type::nullref:
       case wasm::Type::exnref:
       case wasm::Type::none:
       case wasm::Type::unreachable:

src/parsing.h

@@ -265,7 +265,6 @@ parseConst(cashew::IString s, Type type, MixedArena& allocator) {
     case Type::v128:
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref:
       WASM_UNREACHABLE("unexpected const type");
     case Type::none:

src/passes/ConstHoisting.cpp

@@ -96,7 +96,6 @@ struct ConstHoisting : public WalkerPass<PostWalker<ConstHoisting>> {
       case Type::v128:
       case Type::funcref:
       case Type::externref:
-      case Type::nullref:
       case Type::exnref: {
         return false;
       }

src/passes/Flatten.cpp

@@ -211,19 +211,19 @@ struct Flatten
             // the return type of the block this branch is targetting, which may
             // not be the same with the innermost block's return type. For
             // example,
-            // (block $any (result externref)
-            //   (block (result nullref)
+            // (block $any (result anyref)
+            //   (block (result funcref)
             //     (local.tee $0
             //       (br_if $any
-            //         (ref.null)
+            //         (ref.null func)
             //         (i32.const 0)
             //       )
             //     )
             //   )
             // )
             // In this case we need two locals to store (ref.null); one with
-            // externref type that's for the target block ($label0) and one more
-            // with nullref type in case for flowing out. Here we create the
+            // funcref type that's for the target block ($label0) and one more
+            // with anyref type in case for flowing out. Here we create the
             // second 'flowing out' local in case two block's types are
             // different.
             if (type != blockType) {

src/passes/FuncCastEmulation.cpp

@@ -67,7 +67,6 @@ static Expression* toABI(Expression* value, Module* module) {
     }
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref: {
       WASM_UNREACHABLE("reference types cannot be converted to i64");
     }
@@ -111,7 +110,6 @@ static Expression* fromABI(Expression* value, Type type, Module* module) {
     }
     case Type::funcref:
     case Type::externref:
-    case Type::nullref:
     case Type::exnref: {
       WASM_UNREACHABLE("reference types cannot be converted from i64");
     }