summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/binaryen-c.cpp22
-rw-r--r--src/binaryen-c.h12
-rw-r--r--src/gen-s-parser.inc2
-rw-r--r--src/ir/ReFinalize.cpp2
-rw-r--r--src/ir/cost.h2
-rw-r--r--src/ir/effects.h2
-rw-r--r--src/js/binaryen.js-post.js15
-rw-r--r--src/passes/Print.cpp12
-rw-r--r--src/tools/fuzzing.h3
-rw-r--r--src/wasm-binary.h2
-rw-r--r--src/wasm-builder.h5
-rw-r--r--src/wasm-delegations-fields.h9
-rw-r--r--src/wasm-delegations.h2
-rw-r--r--src/wasm-interpreter.h11
-rw-r--r--src/wasm-s-parser.h2
-rw-r--r--src/wasm.h16
-rw-r--r--src/wasm/wasm-binary.cpp13
-rw-r--r--src/wasm/wasm-s-parser.cpp11
-rw-r--r--src/wasm/wasm-stack.cpp10
-rw-r--r--src/wasm/wasm-validator.cpp8
-rw-r--r--src/wasm/wasm.cpp11
-rw-r--r--src/wasm2js.h6
22 files changed, 115 insertions, 63 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 1845d39f3..d66efbe8b 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -705,6 +705,7 @@ BinaryenOp BinaryenWidenHighUVecI16x8ToVecI32x4(void) {
return WidenHighUVecI16x8ToVecI32x4;
}
BinaryenOp BinaryenSwizzleVec8x16(void) { return SwizzleVec8x16; }
+BinaryenOp BinaryenRefIsNull(void) { return RefIsNull; }
BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module,
const char* name,
@@ -1180,10 +1181,11 @@ BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module,
return static_cast<Expression*>(Builder(*(Module*)module).makeRefNull(type_));
}
-BinaryenExpressionRef BinaryenRefIsNull(BinaryenModuleRef module,
- BinaryenExpressionRef value) {
+BinaryenExpressionRef BinaryenRefIs(BinaryenModuleRef module,
+ BinaryenOp op,
+ BinaryenExpressionRef value) {
return static_cast<Expression*>(
- Builder(*(Module*)module).makeRefIsNull((Expression*)value));
+ Builder(*(Module*)module).makeRefIs(RefIsOp(op), (Expression*)value));
}
BinaryenExpressionRef
@@ -2696,17 +2698,17 @@ void BinaryenMemoryFillSetSize(BinaryenExpressionRef expr,
static_cast<MemoryFill*>(expression)->size = (Expression*)sizeExpr;
}
// RefIsNull
-BinaryenExpressionRef BinaryenRefIsNullGetValue(BinaryenExpressionRef expr) {
+BinaryenExpressionRef BinaryenRefIsGetValue(BinaryenExpressionRef expr) {
auto* expression = (Expression*)expr;
- assert(expression->is<RefIsNull>());
- return static_cast<RefIsNull*>(expression)->value;
+ assert(expression->is<RefIs>());
+ return static_cast<RefIs*>(expression)->value;
}
-void BinaryenRefIsNullSetValue(BinaryenExpressionRef expr,
- BinaryenExpressionRef valueExpr) {
+void BinaryenRefIsSetValue(BinaryenExpressionRef expr,
+ BinaryenExpressionRef valueExpr) {
auto* expression = (Expression*)expr;
- assert(expression->is<RefIsNull>());
+ assert(expression->is<RefIs>());
assert(valueExpr);
- static_cast<RefIsNull*>(expression)->value = (Expression*)valueExpr;
+ static_cast<RefIs*>(expression)->value = (Expression*)valueExpr;
}
// RefFunc
const char* BinaryenRefFuncGetFunc(BinaryenExpressionRef expr) {
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index f2d433fc4..7a7ff9e30 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -558,6 +558,7 @@ BINARYEN_API BinaryenOp BinaryenWidenHighSVecI16x8ToVecI32x4(void);
BINARYEN_API BinaryenOp BinaryenWidenLowUVecI16x8ToVecI32x4(void);
BINARYEN_API BinaryenOp BinaryenWidenHighUVecI16x8ToVecI32x4(void);
BINARYEN_API BinaryenOp BinaryenSwizzleVec8x16(void);
+BINARYEN_API BinaryenOp BinaryenRefIsNull(void);
BINARYEN_REF(Expression);
@@ -787,8 +788,9 @@ BinaryenMemoryFill(BinaryenModuleRef module,
BinaryenExpressionRef size);
BINARYEN_API BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module,
BinaryenType type);
-BINARYEN_API BinaryenExpressionRef
-BinaryenRefIsNull(BinaryenModuleRef module, BinaryenExpressionRef value);
+BINARYEN_API BinaryenExpressionRef BinaryenRefIs(BinaryenModuleRef module,
+ BinaryenOp op,
+ BinaryenExpressionRef value);
BINARYEN_API BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module,
const char* func,
BinaryenType type);
@@ -1676,10 +1678,10 @@ BINARYEN_API void BinaryenMemoryFillSetSize(BinaryenExpressionRef expr,
// Gets the value expression tested to be null of a `ref.is_null` expression.
BINARYEN_API BinaryenExpressionRef
-BinaryenRefIsNullGetValue(BinaryenExpressionRef expr);
+BinaryenRefIsGetValue(BinaryenExpressionRef expr);
// Sets the value expression tested to be null of a `ref.is_null` expression.
-BINARYEN_API void BinaryenRefIsNullSetValue(BinaryenExpressionRef expr,
- BinaryenExpressionRef valueExpr);
+BINARYEN_API void BinaryenRefIsSetValue(BinaryenExpressionRef expr,
+ BinaryenExpressionRef valueExpr);
// RefFunc
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 93f064c89..219e07ea4 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -2834,7 +2834,7 @@ switch (op[0]) {
if (strcmp(op, "ref.func") == 0) { return makeRefFunc(s); }
goto parse_error;
case 'i':
- if (strcmp(op, "ref.is_null") == 0) { return makeRefIsNull(s); }
+ if (strcmp(op, "ref.is_null") == 0) { return makeRefIs(s); }
goto parse_error;
case 'n':
if (strcmp(op, "ref.null") == 0) { return makeRefNull(s); }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index 014ee184e..785b36c80 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -126,7 +126,7 @@ void ReFinalize::visitReturn(Return* curr) { curr->finalize(); }
void ReFinalize::visitMemorySize(MemorySize* curr) { curr->finalize(); }
void ReFinalize::visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); }
void ReFinalize::visitRefNull(RefNull* curr) { curr->finalize(); }
-void ReFinalize::visitRefIsNull(RefIsNull* curr) { curr->finalize(); }
+void ReFinalize::visitRefIs(RefIs* curr) { curr->finalize(); }
void ReFinalize::visitRefFunc(RefFunc* curr) {
// TODO: should we look up the function and update the type from there? This
// could handle a change to the function's type, but is also not really what
diff --git a/src/ir/cost.h b/src/ir/cost.h
index 46213880b..95c483601 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -545,7 +545,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, Index> {
}
Index visitPrefetch(Prefetch* curr) { return 0 + visit(curr->ptr); }
Index visitRefNull(RefNull* curr) { return 1; }
- Index visitRefIsNull(RefIsNull* curr) { return 1 + visit(curr->value); }
+ Index visitRefIs(RefIs* curr) { return 1 + visit(curr->value); }
Index visitRefFunc(RefFunc* curr) { return 1; }
Index visitRefEq(RefEq* curr) {
return 1 + visit(curr->left) + visit(curr->right);
diff --git a/src/ir/effects.h b/src/ir/effects.h
index e9e8d0f6c..603ed49a3 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -522,7 +522,7 @@ private:
parent.isAtomic = true;
}
void visitRefNull(RefNull* curr) {}
- void visitRefIsNull(RefIsNull* curr) {}
+ void visitRefIs(RefIs* curr) {}
void visitRefFunc(RefFunc* curr) {}
void visitRefEq(RefEq* curr) {}
void visitTry(Try* curr) {}
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 8c6730e9e..c6d1fe31d 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -87,7 +87,7 @@ function initializeConstants() {
'MemoryCopy',
'MemoryFill',
'RefNull',
- 'RefIsNull',
+ 'RefIs',
'RefFunc',
'RefEq',
'Try',
@@ -486,6 +486,7 @@ function initializeConstants() {
'WidenLowUVecI16x8ToVecI32x4',
'WidenHighUVecI16x8ToVecI32x4',
'SwizzleVec8x16',
+ 'RefIsNull',
].forEach(name => {
Module['Operations'][name] = Module[name] = Module['_Binaryen' + name]();
});
@@ -2102,7 +2103,7 @@ function wrapModule(module, self = {}) {
return Module['_BinaryenRefNull'](module, type);
},
'is_null'(value) {
- return Module['_BinaryenRefIsNull'](module, value);
+ return Module['_BinaryenRefIs'](module, Module['RefIsNull'], value);
},
'func'(func, type) {
return preserveStack(() => Module['_BinaryenRefFunc'](module, strToStack(func), type));
@@ -2840,11 +2841,11 @@ Module['getExpressionInfo'] = function(expr) {
'id': id,
'type': type
};
- case Module['RefIsNullId']:
+ case Module['RefIsId']:
return {
'id': id,
'type': type,
- 'value': Module['_BinaryenRefIsNullGetValue'](expr)
+ 'value': Module['_BinaryenRefIsGetValue'](expr)
};
case Module['RefFuncId']:
return {
@@ -4081,12 +4082,12 @@ Module['MemoryFill'] = makeExpressionWrapper({
}
});
-Module['RefIsNull'] = makeExpressionWrapper({
+Module['RefIs'] = makeExpressionWrapper({
'getValue'(expr) {
- return Module['_BinaryenRefIsNullGetValue'](expr);
+ return Module['_BinaryenRefIsGetValue'](expr);
},
'setValue'(expr, valueExpr) {
- Module['_BinaryenRefIsNullSetValue'](expr, valueExpr);
+ Module['_BinaryenRefIsSetValue'](expr, valueExpr);
}
});
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 7b35701d4..243c3ff8d 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1712,7 +1712,15 @@ struct PrintExpressionContents
printMedium(o, "ref.null ");
printHeapTypeName(o, curr->type.getHeapType());
}
- void visitRefIsNull(RefIsNull* curr) { printMedium(o, "ref.is_null"); }
+ void visitRefIs(RefIs* curr) {
+ switch (curr->op) {
+ case RefIsNull:
+ printMedium(o, "ref.is_null");
+ break;
+ default:
+ WASM_UNREACHABLE("unimplemented ref.is_*");
+ }
+ }
void visitRefFunc(RefFunc* curr) {
printMedium(o, "ref.func ");
printName(curr->func, o);
@@ -2356,7 +2364,7 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
PrintExpressionContents(currFunction, o).visit(curr);
o << ')';
}
- void visitRefIsNull(RefIsNull* curr) {
+ void visitRefIs(RefIs* curr) {
o << '(';
PrintExpressionContents(currFunction, o).visit(curr);
incIndent();
diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h
index 7e5a56ab1..22d9a12e6 100644
--- a/src/tools/fuzzing.h
+++ b/src/tools/fuzzing.h
@@ -2943,10 +2943,11 @@ private:
WASM_UNREACHABLE("invalid value");
}
+ // TODO: support other RefIs variants, and rename this
Expression* makeRefIsNull(Type type) {
assert(type == Type::i32);
assert(wasm.features.hasReferenceTypes());
- return builder.makeRefIsNull(make(getReferenceType()));
+ return builder.makeRefIs(RefIsNull, make(getReferenceType()));
}
Expression* makeRefEq(Type type) {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index a495300dc..2df38b282 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1536,7 +1536,7 @@ public:
void visitUnreachable(Unreachable* curr);
void visitDrop(Drop* curr);
void visitRefNull(RefNull* curr);
- void visitRefIsNull(RefIsNull* curr);
+ void visitRefIs(RefIs* curr, uint8_t code);
void visitRefFunc(RefFunc* curr);
void visitRefEq(RefEq* curr);
void visitTryOrTryInBlock(Expression*& out);
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index da74f47ef..9f74f05d2 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -605,8 +605,9 @@ public:
ret->finalize(type);
return ret;
}
- RefIsNull* makeRefIsNull(Expression* value) {
- auto* ret = wasm.allocator.alloc<RefIsNull>();
+ RefIs* makeRefIs(RefIsOp op, Expression* value) {
+ auto* ret = wasm.allocator.alloc<RefIs>();
+ ret->op = op;
ret->value = value;
ret->finalize();
return ret;
diff --git a/src/wasm-delegations-fields.h b/src/wasm-delegations-fields.h
index 60e14d0c5..ad137e58d 100644
--- a/src/wasm-delegations-fields.h
+++ b/src/wasm-delegations-fields.h
@@ -484,10 +484,11 @@ switch (DELEGATE_ID) {
DELEGATE_END(RefNull);
break;
}
- case Expression::Id::RefIsNullId: {
- DELEGATE_START(RefIsNull);
- DELEGATE_FIELD_CHILD(RefIsNull, value);
- DELEGATE_END(RefIsNull);
+ case Expression::Id::RefIsId: {
+ DELEGATE_START(RefIs);
+ DELEGATE_FIELD_INT(RefIs, op);
+ DELEGATE_FIELD_CHILD(RefIs, value);
+ DELEGATE_END(RefIs);
break;
}
case Expression::Id::RefFuncId: {
diff --git a/src/wasm-delegations.h b/src/wasm-delegations.h
index f9e163286..04df283c3 100644
--- a/src/wasm-delegations.h
+++ b/src/wasm-delegations.h
@@ -56,7 +56,7 @@ DELEGATE(MemoryGrow);
DELEGATE(Unreachable);
DELEGATE(Pop);
DELEGATE(RefNull);
-DELEGATE(RefIsNull);
+DELEGATE(RefIs);
DELEGATE(RefFunc);
DELEGATE(RefEq);
DELEGATE(Try);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 44173d395..1d07af46a 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1306,15 +1306,20 @@ public:
NOTE_ENTER("RefNull");
return Literal::makeNull(curr->type);
}
- Flow visitRefIsNull(RefIsNull* curr) {
- NOTE_ENTER("RefIsNull");
+ Flow visitRefIs(RefIs* curr) {
+ NOTE_ENTER("RefIs");
Flow flow = visit(curr->value);
if (flow.breaking()) {
return flow;
}
const auto& value = flow.getSingleValue();
NOTE_EVAL1(value);
- return Literal(value.isNull());
+ switch (curr->op) {
+ case RefIsNull:
+ return Literal(value.isNull());
+ default:
+ WASM_UNREACHABLE("unimplemented ref.is_*");
+ }
}
Flow visitRefFunc(RefFunc* curr) {
NOTE_ENTER("RefFunc");
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index b6db598ec..0fba3bba0 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -244,7 +244,7 @@ private:
Expression* makeBreakTable(Element& s);
Expression* makeReturn(Element& s);
Expression* makeRefNull(Element& s);
- Expression* makeRefIsNull(Element& s);
+ Expression* makeRefIs(Element& s);
Expression* makeRefFunc(Element& s);
Expression* makeRefEq(Element& s);
Expression* makeTry(Element& s);
diff --git a/src/wasm.h b/src/wasm.h
index 7090aeff1..949ec3b72 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -542,6 +542,13 @@ enum PrefetchOp {
PrefetchNontemporal,
};
+enum RefIsOp {
+ RefIsNull,
+ RefIsFunc,
+ RefIsData,
+ RefIsI31,
+};
+
//
// Expressions
//
@@ -609,7 +616,7 @@ public:
MemoryFillId,
PopId,
RefNullId,
- RefIsNullId,
+ RefIsId,
RefFuncId,
RefEqId,
TryId,
@@ -1228,9 +1235,12 @@ public:
void finalize(Type type);
};
-class RefIsNull : public SpecificExpression<Expression::RefIsNullId> {
+class RefIs : public SpecificExpression<Expression::RefIsId> {
public:
- RefIsNull(MixedArena& allocator) {}
+ RefIs(MixedArena& allocator) {}
+
+ // RefIs can represent ref.is_null, ref.is_func, ref.is_data, and ref.is_i31.
+ RefIsOp op;
Expression* value;
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index bf71d3a4d..b3f085b36 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -2865,7 +2865,7 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) {
visitRefNull((curr = allocator.alloc<RefNull>())->cast<RefNull>());
break;
case BinaryConsts::RefIsNull:
- visitRefIsNull((curr = allocator.alloc<RefIsNull>())->cast<RefIsNull>());
+ visitRefIs((curr = allocator.alloc<RefIs>())->cast<RefIs>(), code);
break;
case BinaryConsts::RefFunc:
visitRefFunc((curr = allocator.alloc<RefFunc>())->cast<RefFunc>());
@@ -5528,8 +5528,15 @@ void WasmBinaryBuilder::visitRefNull(RefNull* curr) {
curr->finalize(getHeapType());
}
-void WasmBinaryBuilder::visitRefIsNull(RefIsNull* curr) {
- BYN_TRACE("zz node: RefIsNull\n");
+void WasmBinaryBuilder::visitRefIs(RefIs* curr, uint8_t code) {
+ BYN_TRACE("zz node: RefIs\n");
+ switch (code) {
+ case BinaryConsts::RefIsNull:
+ curr->op = RefIsNull;
+ break;
+ default:
+ WASM_UNREACHABLE("invalid code for ref.is_*");
+ }
curr->value = popNonVoidExpression();
curr->finalize();
}
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 857c0143b..b2212db18 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -51,7 +51,7 @@ int unhex(char c) {
namespace wasm {
static Name STRUCT("struct"), FIELD("field"), ARRAY("array"), I8("i8"),
- I16("i16"), RTT("rtt");
+ I16("i16"), RTT("rtt"), REF_IS_NULL("ref.is_null");
static Address getAddress(const Element* s) { return atoll(s->c_str()); }
@@ -1922,8 +1922,13 @@ Expression* SExpressionWasmBuilder::makeRefNull(Element& s) {
return ret;
}
-Expression* SExpressionWasmBuilder::makeRefIsNull(Element& s) {
- auto ret = allocator.alloc<RefIsNull>();
+Expression* SExpressionWasmBuilder::makeRefIs(Element& s) {
+ auto ret = allocator.alloc<RefIs>();
+ if (*s[0] == REF_IS_NULL) {
+ ret->op = RefIsNull;
+ } else {
+ WASM_UNREACHABLE("unimplemented ref.is_*");
+ }
ret->value = parseExpression(s[1]);
ret->finalize();
return ret;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index fae9da140..7b902ad67 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -1864,8 +1864,14 @@ void BinaryInstWriter::visitRefNull(RefNull* curr) {
parent.writeHeapType(curr->type.getHeapType());
}
-void BinaryInstWriter::visitRefIsNull(RefIsNull* curr) {
- o << int8_t(BinaryConsts::RefIsNull);
+void BinaryInstWriter::visitRefIs(RefIs* curr) {
+ switch (curr->op) {
+ case RefIsNull:
+ o << int8_t(BinaryConsts::RefIsNull);
+ break;
+ default:
+ WASM_UNREACHABLE("unimplemented ref.is_*");
+ }
}
void BinaryInstWriter::visitRefFunc(RefFunc* curr) {
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index 7cddf5a86..8def0e529 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -331,7 +331,7 @@ public:
void visitMemorySize(MemorySize* curr);
void visitMemoryGrow(MemoryGrow* curr);
void visitRefNull(RefNull* curr);
- void visitRefIsNull(RefIsNull* curr);
+ void visitRefIs(RefIs* curr);
void visitRefFunc(RefFunc* curr);
void visitRefEq(RefEq* curr);
void visitTry(Try* curr);
@@ -1981,14 +1981,14 @@ void FunctionValidator::visitRefNull(RefNull* curr) {
curr->type.isNullable(), curr, "ref.null types must be nullable");
}
-void FunctionValidator::visitRefIsNull(RefIsNull* curr) {
+void FunctionValidator::visitRefIs(RefIs* curr) {
shouldBeTrue(getModule()->features.hasReferenceTypes(),
curr,
- "ref.is_null requires reference-types to be enabled");
+ "ref.is_* requires reference-types to be enabled");
shouldBeTrue(curr->value->type == Type::unreachable ||
curr->value->type.isRef(),
curr->value,
- "ref.is_null's argument should be a reference type");
+ "ref.is_*'s argument should be a reference type");
}
void FunctionValidator::visitRefFunc(RefFunc* curr) {
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index 13085ca17..f2f08033e 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -188,8 +188,13 @@ const char* getExpressionName(Expression* curr) {
return "pop";
case Expression::Id::RefNullId:
return "ref.null";
- case Expression::Id::RefIsNullId:
- return "ref.is_null";
+ case Expression::Id::RefIsId:
+ switch (curr->cast<RefIs>()->op) {
+ case RefIsNull:
+ return "ref.is_null";
+ default:
+ WASM_UNREACHABLE("unimplemented ref.is_*");
+ }
case Expression::Id::RefFuncId:
return "ref.func";
case Expression::Id::RefEqId:
@@ -929,7 +934,7 @@ void RefNull::finalize(Type type_) {
void RefNull::finalize() {
}
-void RefIsNull::finalize() {
+void RefIs::finalize() {
if (value->type == Type::unreachable) {
type = Type::unreachable;
return;
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 745a56d59..ba7b55c08 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -1637,9 +1637,7 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
RSHIFT,
ValueBuilder::makeNum(16));
}
- default: {
- Fatal() << "Unhandled unary i32 operator: " << curr;
- }
+ default: { WASM_UNREACHABLE("unhandled unary"); }
}
}
case Type::f32:
@@ -2151,7 +2149,7 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
unimplemented(curr);
WASM_UNREACHABLE("unimp");
}
- Ref visitRefIsNull(RefIsNull* curr) {
+ Ref visitRefIs(RefIs* curr) {
unimplemented(curr);
WASM_UNREACHABLE("unimp");
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-05 17:35:31 +0000