summaryrefslogtreecommitdiff
path: root/src/wasm-interpreter.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/wasm-interpreter.h')
-rw-r--r--src/wasm-interpreter.h126
1 files changed, 63 insertions, 63 deletions
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 21ccd7a47..3ac3cf1e4 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -489,105 +489,105 @@ private:
assert(isConcreteWasmType(curr->right->type) ? right.type == curr->right->type : true);
if (left.type == i32) {
switch (curr->op) {
- case Add: return left.add(right);
- case Sub: return left.sub(right);
- case Mul: return left.mul(right);
- case DivS: {
+ case AddInt32: return left.add(right);
+ case SubInt32: return left.sub(right);
+ case MulInt32: return left.mul(right);
+ case DivSInt32: {
if (right.getInteger() == 0) trap("i32.div_s by 0");
if (left.getInteger() == std::numeric_limits<int32_t>::min() && right.getInteger() == -1) trap("i32.div_s overflow"); // signed division overflow
return left.divS(right);
}
- case DivU: {
+ case DivUInt32: {
if (right.getInteger() == 0) trap("i32.div_u by 0");
return left.divU(right);
}
- case RemS: {
+ case RemSInt32: {
if (right.getInteger() == 0) trap("i32.rem_s by 0");
if (left.getInteger() == std::numeric_limits<int32_t>::min() && right.getInteger() == -1) return Literal(int32_t(0));
return left.remS(right);
}
- case RemU: {
+ case RemUInt32: {
if (right.getInteger() == 0) trap("i32.rem_u by 0");
return left.remU(right);
}
- case And: return left.and_(right);
- case Or: return left.or_(right);
- case Xor: return left.xor_(right);
- case Shl: return left.shl(right.and_(Literal(int32_t(31))));
- case ShrU: return left.shrU(right.and_(Literal(int32_t(31))));
- case ShrS: return left.shrS(right.and_(Literal(int32_t(31))));
- case RotL: return left.rotL(right);
- case RotR: return left.rotR(right);
- case Eq: return left.eq(right);
- case Ne: return left.ne(right);
- case LtS: return left.ltS(right);
- case LtU: return left.ltU(right);
- case LeS: return left.leS(right);
- case LeU: return left.leU(right);
- case GtS: return left.gtS(right);
- case GtU: return left.gtU(right);
- case GeS: return left.geS(right);
- case GeU: return left.geU(right);
+ case AndInt32: return left.and_(right);
+ case OrInt32: return left.or_(right);
+ case XorInt32: return left.xor_(right);
+ case ShlInt32: return left.shl(right.and_(Literal(int32_t(31))));
+ case ShrUInt32: return left.shrU(right.and_(Literal(int32_t(31))));
+ case ShrSInt32: return left.shrS(right.and_(Literal(int32_t(31))));
+ case RotLInt32: return left.rotL(right);
+ case RotRInt32: return left.rotR(right);
+ case EqInt32: return left.eq(right);
+ case NeInt32: return left.ne(right);
+ case LtSInt32: return left.ltS(right);
+ case LtUInt32: return left.ltU(right);
+ case LeSInt32: return left.leS(right);
+ case LeUInt32: return left.leU(right);
+ case GtSInt32: return left.gtS(right);
+ case GtUInt32: return left.gtU(right);
+ case GeSInt32: return left.geS(right);
+ case GeUInt32: return left.geU(right);
default: abort();
}
} else if (left.type == i64) {
switch (curr->op) {
- case Add: return left.add(right);
- case Sub: return left.sub(right);
- case Mul: return left.mul(right);
- case DivS: {
+ case AddInt64: return left.add(right);
+ case SubInt64: return left.sub(right);
+ case MulInt64: return left.mul(right);
+ case DivSInt64: {
if (right.getInteger() == 0) trap("i64.div_s by 0");
if (left.getInteger() == LLONG_MIN && right.getInteger() == -1LL) trap("i64.div_s overflow"); // signed division overflow
return left.divS(right);
}
- case DivU: {
+ case DivUInt64: {
if (right.getInteger() == 0) trap("i64.div_u by 0");
return left.divU(right);
}
- case RemS: {
+ case RemSInt64: {
if (right.getInteger() == 0) trap("i64.rem_s by 0");
if (left.getInteger() == LLONG_MIN && right.getInteger() == -1LL) return Literal(int64_t(0));
return left.remS(right);
}
- case RemU: {
+ case RemUInt64: {
if (right.getInteger() == 0) trap("i64.rem_u by 0");
return left.remU(right);
}
- case And: return left.and_(right);
- case Or: return left.or_(right);
- case Xor: return left.xor_(right);
- case Shl: return left.shl(right.and_(Literal(int64_t(63))));
- case ShrU: return left.shrU(right.and_(Literal(int64_t(63))));
- case ShrS: return left.shrS(right.and_(Literal(int64_t(63))));
- case RotL: return left.rotL(right);
- case RotR: return left.rotR(right);
- case Eq: return left.eq(right);
- case Ne: return left.ne(right);
- case LtS: return left.ltS(right);
- case LtU: return left.ltU(right);
- case LeS: return left.leS(right);
- case LeU: return left.leU(right);
- case GtS: return left.gtS(right);
- case GtU: return left.gtU(right);
- case GeS: return left.geS(right);
- case GeU: return left.geU(right);
+ case AndInt64: return left.and_(right);
+ case OrInt64: return left.or_(right);
+ case XorInt64: return left.xor_(right);
+ case ShlInt64: return left.shl(right.and_(Literal(int64_t(63))));
+ case ShrUInt64: return left.shrU(right.and_(Literal(int64_t(63))));
+ case ShrSInt64: return left.shrS(right.and_(Literal(int64_t(63))));
+ case RotLInt64: return left.rotL(right);
+ case RotRInt64: return left.rotR(right);
+ case EqInt64: return left.eq(right);
+ case NeInt64: return left.ne(right);
+ case LtSInt64: return left.ltS(right);
+ case LtUInt64: return left.ltU(right);
+ case LeSInt64: return left.leS(right);
+ case LeUInt64: return left.leU(right);
+ case GtSInt64: return left.gtS(right);
+ case GtUInt64: return left.gtU(right);
+ case GeSInt64: return left.geS(right);
+ case GeUInt64: return left.geU(right);
default: abort();
}
} else if (left.type == f32 || left.type == f64) {
switch (curr->op) {
- case Add: return left.add(right);
- case Sub: return left.sub(right);
- case Mul: return left.mul(right);
- case Div: return left.div(right);
- case CopySign: return left.copysign(right);
- case Min: return left.min(right);
- case Max: return left.max(right);
- case Eq: return left.eq(right);
- case Ne: return left.ne(right);
- case Lt: return left.lt(right);
- case Le: return left.le(right);
- case Gt: return left.gt(right);
- case Ge: return left.ge(right);
+ case AddFloat32: case AddFloat64: return left.add(right);
+ case SubFloat32: case SubFloat64: return left.sub(right);
+ case MulFloat32: case MulFloat64: return left.mul(right);
+ case DivFloat32: case DivFloat64: return left.div(right);
+ case CopySignFloat32: case CopySignFloat64: return left.copysign(right);
+ case MinFloat32: case MinFloat64: return left.min(right);
+ case MaxFloat32: case MaxFloat64: return left.max(right);
+ case EqFloat32: case EqFloat64: return left.eq(right);
+ case NeFloat32: case NeFloat64: return left.ne(right);
+ case LtFloat32: case LtFloat64: return left.lt(right);
+ case LeFloat32: case LeFloat64: return left.le(right);
+ case GtFloat32: case GtFloat64: return left.gt(right);
+ case GeFloat32: case GeFloat64: return left.ge(right);
default: abort();
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-06 18:27:01 +0000