Rename except_ref type to exnref (#2224)

In WebAssembly/exception-handling#79 we agreed to rename `except_ref`
type to `exnref`.

Author: aheejin

build-js.sh

@@ -184,7 +184,7 @@ export_function "_BinaryenTypeInt64"
 export_function "_BinaryenTypeFloat32"
 export_function "_BinaryenTypeFloat64"
 export_function "_BinaryenTypeVec128"
-export_function "_BinaryenTypeExceptRef"
+export_function "_BinaryenTypeExnref"
 export_function "_BinaryenTypeUnreachable"
 export_function "_BinaryenTypeAuto"
 

src/asmjs/asm_v_wasm.cpp

@@ -53,8 +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 exnref:
+      assert(false && "exnref is not in asm2wasm");
     case none:
       return ASM_NONE;
     case unreachable:
@@ -75,7 +75,7 @@ char getSig(Type type) {
       return 'd';
     case v128:
       return 'V';
-    case except_ref:
+    case exnref:
       return 'e';
     case none:
       return 'v';
@@ -106,7 +106,7 @@ Type sigToType(char sig) {
     case 'V':
       return v128;
     case 'e':
-      return except_ref;
+      return exnref;
     case 'v':
       return none;
     default:

src/binaryen-c.cpp

@@ -70,7 +70,7 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
       break;
     }
 
-    case Type::except_ref: // there's no except_ref literals
+    case Type::exnref: // there's no exnref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -90,7 +90,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::exnref: // there's no exnref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -210,7 +210,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::exnref: // there's no exnref literals
     case Type::none:
     case Type::unreachable:
       WASM_UNREACHABLE();
@@ -265,7 +265,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 BinaryenTypeExnref(void) { return exnref; }
 BinaryenType BinaryenTypeUnreachable(void) { return unreachable; }
 BinaryenType BinaryenTypeAuto(void) { return uint32_t(-1); }
 

src/binaryen-c.h

@@ -74,7 +74,7 @@ BinaryenType BinaryenTypeInt64(void);
 BinaryenType BinaryenTypeFloat32(void);
 BinaryenType BinaryenTypeFloat64(void);
 BinaryenType BinaryenTypeVec128(void);
-BinaryenType BinaryenTypeExceptRef(void);
+BinaryenType BinaryenTypeExnref(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.

src/ir/abstract.h

@@ -81,7 +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 exnref: // there's no unary instructions for exnref
     case none:
     case unreachable: {
       return InvalidUnary;
@@ -212,7 +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 exnref: // there's no binary instructions for exnref
     case none:
     case unreachable: {
       return InvalidBinary;

src/js/binaryen.js-post.js

@@ -37,7 +37,7 @@ Module['i64'] = Module['_BinaryenTypeInt64']();
 Module['f32'] = Module['_BinaryenTypeFloat32']();
 Module['f64'] = Module['_BinaryenTypeFloat64']();
 Module['v128'] = Module['_BinaryenTypeVec128']();
-Module['except_ref'] = Module['_BinaryenTypeExceptRef']();
+Module['exnref'] = Module['_BinaryenTypeExnref']();
 Module['unreachable'] = Module['_BinaryenTypeUnreachable']();
 Module['auto'] = /* deprecated */ Module['undefined'] = Module['_BinaryenTypeAuto']();
 

src/literal.h

@@ -80,7 +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 Type::exnref: // there's no exnref literals
       case none:
       case unreachable:
         WASM_UNREACHABLE();
@@ -430,7 +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::exnref: // exnref is an opaque value
       case wasm::Type::none:
       case wasm::Type::unreachable:
         return false;

src/parsing.h

@@ -263,7 +263,7 @@ parseConst(cashew::IString s, Type type, MixedArena& allocator) {
       break;
     }
     case v128:
-    case except_ref: // there's no except_ref.const
+    case exnref: // there's no exnref.const
       WASM_UNREACHABLE();
     case none:
     case unreachable: {

src/passes/ConstHoisting.cpp

@@ -95,8 +95,8 @@ struct ConstHoisting : public WalkerPass<PostWalker<ConstHoisting>> {
         // v128 not implemented yet
         return false;
       }
-      case except_ref: {
-        // except_ref cannot have literals
+      case exnref: {
+        // exnref cannot have literals
         return false;
       }
       case none:

src/passes/FuncCastEmulation.cpp

@@ -66,8 +66,8 @@ 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");
+    case exnref: {
+      assert(false && "exnref cannot be converted to i64");
       WASM_UNREACHABLE();
     }
     case none: {
@@ -108,8 +108,8 @@ 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");
+    case exnref: {
+      assert(false && "exnref cannot be converted from i64");
       WASM_UNREACHABLE();
     }
     case none: {