Add except_ref type (#2081)

This adds except_ref type, which is a part of the exception handling proposal.
WebAssembly · May 8, 2019 · 14a2869 · 14a2869
1 parent da716eb
commit 14a2869
Show file tree

Hide file tree

Showing 33 changed files with 157 additions and 9 deletions.
diff --git a/build-js.sh b/build-js.sh
@@ -180,6 +180,7 @@ export_function "_BinaryenTypeInt64"
 export_function "_BinaryenTypeFloat32"
 export_function "_BinaryenTypeFloat64"
 export_function "_BinaryenTypeVec128"
+export_function "_BinaryenTypeExceptRef"
 export_function "_BinaryenTypeUnreachable"
 export_function "_BinaryenTypeAuto"
 

diff --git a/src/asmjs/asm_v_wasm.cpp b/src/asmjs/asm_v_wasm.cpp
@@ -53,6 +53,8 @@ AsmType wasmToAsmType(Type type) {
       return ASM_INT64;
     case v128:
       assert(false && "v128 not implemented yet");
+    case except_ref:
+      assert(false && "except_ref is not in asm2wasm");
     case none:
       return ASM_NONE;
     case unreachable:
@@ -73,6 +75,8 @@ char getSig(Type type) {
       return 'd';
     case v128:
       return 'V';
+    case except_ref:
+      return 'e';
     case none:
       return 'v';
     case unreachable:
@@ -111,6 +115,8 @@ Type sigToType(char sig) {
       return f64;
     case 'V':
       return v128;
+    case 'e':
+      return except_ref;
     case 'v':
       return none;
     default:

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
@@ -66,6 +66,8 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
       memcpy(&ret.v128, x.getv128Ptr(), 16);
       break;
     }
+
+    case Type::except_ref: // there's no except_ref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -85,6 +87,7 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
       return Literal(x.i64).castToF64();
     case Type::v128:
       return Literal(x.v128);
+    case Type::except_ref: // there's no except_ref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -203,6 +206,7 @@ void printArg(std::ostream& setup, std::ostream& out, BinaryenLiteral arg) {
       out << "BinaryenLiteralVec128(" << array << ")";
       break;
     }
+    case Type::except_ref: // there's no except_ref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -257,6 +261,7 @@ BinaryenType BinaryenTypeInt64(void) { return i64; }
 BinaryenType BinaryenTypeFloat32(void) { return f32; }
 BinaryenType BinaryenTypeFloat64(void) { return f64; }
 BinaryenType BinaryenTypeVec128(void) { return v128; }
+BinaryenType BinaryenTypeExceptRef(void) { return except_ref; }
 BinaryenType BinaryenTypeUnreachable(void) { return unreachable; }
 BinaryenType BinaryenTypeAuto(void) { return uint32_t(-1); }
 

diff --git a/src/binaryen-c.h b/src/binaryen-c.h
@@ -74,6 +74,7 @@ BinaryenType BinaryenTypeInt64(void);
 BinaryenType BinaryenTypeFloat32(void);
 BinaryenType BinaryenTypeFloat64(void);
 BinaryenType BinaryenTypeVec128(void);
+BinaryenType BinaryenTypeExceptRef(void);
 BinaryenType BinaryenTypeUnreachable(void);
 // Not a real type. Used as the last parameter to BinaryenBlock to let
 // the API figure out the type instead of providing one.

diff --git a/src/ir/abstract.h b/src/ir/abstract.h
@@ -81,6 +81,7 @@ inline UnaryOp getUnary(Type type, Op op) {
       assert(false && "v128 not implemented yet");
       WASM_UNREACHABLE();
     }
+    case except_ref: // there's no unary instructions for except_ref
     case none:
     case unreachable: {
       return InvalidUnary;
@@ -211,6 +212,7 @@ inline BinaryOp getBinary(Type type, Op op) {
       assert(false && "v128 not implemented yet");
       WASM_UNREACHABLE();
     }
+    case except_ref: // there's no binary instructions for except_ref
     case none:
     case unreachable: {
       return InvalidBinary;

diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
@@ -37,6 +37,7 @@ Module['i64'] = Module['_BinaryenTypeInt64']();
 Module['f32'] = Module['_BinaryenTypeFloat32']();
 Module['f64'] = Module['_BinaryenTypeFloat64']();
 Module['v128'] = Module['_BinaryenTypeVec128']();
+Module['except_ref'] = Module['_BinaryenTypeExceptRef']();
 Module['unreachable'] = Module['_BinaryenTypeUnreachable']();
 Module['auto'] = /* deprecated */ Module['undefined'] = Module['_BinaryenTypeAuto']();
 

diff --git a/src/literal.h b/src/literal.h
@@ -80,6 +80,7 @@ class Literal {
                                                Literal(int32_t(0)),
                                                Literal(int32_t(0)),
                                                Literal(int32_t(0))}});
+      case Type::except_ref: // there's no except_ref literals
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -429,6 +430,7 @@ template<> struct less<wasm::Literal> {
         return a.reinterpreti64() < b.reinterpreti64();
       case wasm::Type::v128:
         return memcmp(a.getv128Ptr(), b.getv128Ptr(), 16) < 0;
+      case wasm::Type::except_ref: // except_ref is an opaque value
       case wasm::Type::none:
       case wasm::Type::unreachable:
         return false;

diff --git a/src/parsing.h b/src/parsing.h
@@ -263,6 +263,7 @@ parseConst(cashew::IString s, Type type, MixedArena& allocator) {
       break;
     }
     case v128:
+    case except_ref: // there's no except_ref.const
       WASM_UNREACHABLE();
     case none:
     case unreachable: {

diff --git a/src/passes/ConstHoisting.cpp b/src/passes/ConstHoisting.cpp
@@ -95,6 +95,10 @@ struct ConstHoisting : public WalkerPass<PostWalker<ConstHoisting>> {
         // v128 not implemented yet
         return false;
       }
+      case except_ref: {
+        // except_ref cannot have literals
+        return false;
+      }
       case none:
       case unreachable: {
         WASM_UNREACHABLE();

diff --git a/src/passes/FuncCastEmulation.cpp b/src/passes/FuncCastEmulation.cpp
@@ -66,6 +66,10 @@ static Expression* toABI(Expression* value, Module* module) {
       assert(false && "v128 not implemented yet");
       WASM_UNREACHABLE();
     }
+    case except_ref: {
+      assert(false && "except_ref cannot be converted to i64");
+      WASM_UNREACHABLE();
+    }
     case none: {
       // the value is none, but we need a value here
       value = builder.makeSequence(value, LiteralUtils::makeZero(i64, *module));
@@ -104,6 +108,10 @@ static Expression* fromABI(Expression* value, Type type, Module* module) {
       assert(false && "v128 not implemented yet");
       WASM_UNREACHABLE();
     }
+    case except_ref: {
+      assert(false && "except_ref cannot be converted from i64");
+      WASM_UNREACHABLE();
+    }
     case none: {
       value = builder.makeDrop(value);
     }

diff --git a/src/passes/InstrumentLocals.cpp b/src/passes/InstrumentLocals.cpp
@@ -81,6 +81,8 @@ struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> {
         break;
       case v128:
         assert(false && "v128 not implemented yet");
+      case except_ref:
+        assert(false && "not implemented yet");
       case none:
         WASM_UNREACHABLE();
       case unreachable:
@@ -111,6 +113,8 @@ struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> {
         break;
       case v128:
         assert(false && "v128 not implemented yet");
+      case except_ref:
+        assert(false && "except_ref not implemented yet");
       case unreachable:
         return; // nothing to do here
       case none:

diff --git a/src/shell-interface.h b/src/shell-interface.h
@@ -114,6 +114,8 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
             break;
           case v128:
             assert(false && "v128 not implemented yet");
+          case except_ref:
+            assert(false && "except_ref not implemented yet");
           case none:
           case unreachable:
             WASM_UNREACHABLE();

diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
@@ -25,6 +25,9 @@ high chance for set at start of loop
     high chance of a tee in that case => loop var
 */
 
+// TODO Complete except_ref type support. Its support is partialy implemented
+// and the type is currently not generated in fuzzed programs yet.
+
 #include "ir/memory-utils.h"
 #include <ir/find_all.h>
 #include <ir/literal-utils.h>
@@ -815,6 +818,7 @@ class TranslateToFuzzReader {
       case f32:
       case f64:
       case v128:
+      case except_ref:
         ret = _makeConcrete(type);
         break;
       case none:
@@ -1326,6 +1330,7 @@ class TranslateToFuzzReader {
         return builder.makeLoad(
           16, false, offset, pick(1, 2, 4, 8, 16), ptr, type);
       }
+      case except_ref: // except_ref cannot be loaded from memory
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -1334,7 +1339,8 @@ class TranslateToFuzzReader {
   }
 
   Expression* makeLoad(Type type) {
-    if (!allowMemory) {
+    // except_ref type cannot be stored in memory
+    if (!allowMemory || type == except_ref) {
       return makeTrivial(type);
     }
     auto* ret = makeNonAtomicLoad(type);
@@ -1425,6 +1431,7 @@ class TranslateToFuzzReader {
         return builder.makeStore(
           16, offset, pick(1, 2, 4, 8, 16), ptr, value, type);
       }
+      case except_ref: // except_ref cannot be stored in memory
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -1433,7 +1440,8 @@ class TranslateToFuzzReader {
   }
 
   Expression* makeStore(Type type) {
-    if (!allowMemory) {
+    // except_ref type cannot be stored in memory
+    if (!allowMemory || type == except_ref) {
       return makeTrivial(type);
     }
     auto* ret = makeNonAtomicStore(type);
@@ -1518,6 +1526,7 @@ class TranslateToFuzzReader {
           case f64:
             return Literal(getDouble());
           case v128:
+          case except_ref: // except_ref cannot have literals
           case none:
           case unreachable:
             WASM_UNREACHABLE();
@@ -1559,6 +1568,7 @@ class TranslateToFuzzReader {
           case f64:
             return Literal(double(small));
           case v128:
+          case except_ref: // except_ref cannot have literals
           case none:
           case unreachable:
             WASM_UNREACHABLE();
@@ -1623,6 +1633,7 @@ class TranslateToFuzzReader {
                                          std::numeric_limits<uint64_t>::max()));
             break;
           case v128:
+          case except_ref: // except_ref cannot have literals
           case none:
           case unreachable:
             WASM_UNREACHABLE();
@@ -1653,6 +1664,7 @@ class TranslateToFuzzReader {
             value = Literal(double(int64_t(1) << upTo(64)));
             break;
           case v128:
+          case except_ref: // except_ref cannot have literals
           case none:
           case unreachable:
             WASM_UNREACHABLE();
@@ -1676,6 +1688,12 @@ class TranslateToFuzzReader {
   }
 
   Expression* makeConst(Type type) {
+    if (type == except_ref) {
+      // There's no except_ref.const.
+      // TODO We should return a nullref once we implement instructions for
+      // reference types proposal.
+      assert(false && "except_ref const is not implemented yet");
+    }
     auto* ret = wasm.allocator.alloc<Const>();
     ret->value = makeLiteral(type);
     ret->type = type;
@@ -1694,6 +1712,11 @@ class TranslateToFuzzReader {
       // give up
       return makeTrivial(type);
     }
+    // There's no binary ops for except_ref
+    if (type == except_ref) {
+      makeTrivial(type);
+    }
+
     switch (type) {
       case i32: {
         switch (getConcreteType()) {
@@ -1739,6 +1762,7 @@ class TranslateToFuzzReader {
                                     AllTrueVecI64x2),
                                make(v128)});
           }
+          case except_ref: // there's no unary ops for except_ref
           case none:
           case unreachable:
             WASM_UNREACHABLE();
@@ -1869,6 +1893,7 @@ class TranslateToFuzzReader {
         }
         WASM_UNREACHABLE();
       }
+      case except_ref: // there's no unary ops for except_ref
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -1889,6 +1914,11 @@ class TranslateToFuzzReader {
       // give up
       return makeTrivial(type);
     }
+    // There's no binary ops for except_ref
+    if (type == except_ref) {
+      makeTrivial(type);
+    }
+
     switch (type) {
       case i32: {
         switch (upTo(4)) {
@@ -2076,6 +2106,7 @@ class TranslateToFuzzReader {
                             make(v128),
                             make(v128)});
       }
+      case except_ref: // there's no binary ops for except_ref
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -2269,6 +2300,7 @@ class TranslateToFuzzReader {
         op = ExtractLaneVecF64x2;
         break;
       case v128:
+      case except_ref:
       case none:
       case unreachable:
         WASM_UNREACHABLE();

diff --git a/src/tools/spec-wrapper.h b/src/tools/spec-wrapper.h
@@ -48,6 +48,7 @@ static std::string generateSpecWrapper(Module& wasm) {
         case v128:
           ret += "(v128.const i32x4 0 0 0 0)";
           break;
+        case except_ref: // there's no except_ref.const
         case none:
         case unreachable:
           WASM_UNREACHABLE();

diff --git a/src/tools/wasm-reduce.cpp b/src/tools/wasm-reduce.cpp
@@ -592,7 +592,8 @@ struct Reducer
                 fixed = builder->makeUnary(TruncSFloat64ToInt32, child);
                 break;
               case v128:
-                continue; // v128 not implemented yet
+              case except_ref:
+                continue; // not implemented yet
               case none:
               case unreachable:
                 WASM_UNREACHABLE();
@@ -613,7 +614,8 @@ struct Reducer
                 fixed = builder->makeUnary(TruncSFloat64ToInt64, child);
                 break;
               case v128:
-                continue; // v128 not implemented yet
+              case except_ref:
+                continue; // not implemented yet
               case none:
               case unreachable:
                 WASM_UNREACHABLE();
@@ -634,7 +636,8 @@ struct Reducer
                 fixed = builder->makeUnary(DemoteFloat64, child);
                 break;
               case v128:
-                continue; // v128 not implemented yet
+              case except_ref:
+                continue; // not implemented yet
               case none:
               case unreachable:
                 WASM_UNREACHABLE();
@@ -655,15 +658,17 @@ struct Reducer
               case f64:
                 WASM_UNREACHABLE();
               case v128:
-                continue; // v128 not implemented yet
+              case except_ref:
+                continue; // not implemented yet
               case none:
               case unreachable:
                 WASM_UNREACHABLE();
             }
             break;
           }
           case v128:
-            continue; // v128 not implemented yet
+          case except_ref:
+            continue; // not implemented yet
           case none:
           case unreachable:
             WASM_UNREACHABLE();