Mul / div support

stevenfontanella · stevenfontanella · commit a1c09336fb98 · 2026-04-28T17:55:38.000Z
diff --git a/overview.md b/overview.md
diff --git a/patch.py b/patch.py
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -148,6 +148,8 @@
     ("i64.rotr",       "makeBinary(BinaryOp::RotRInt64)"),
     ("i64.add128",     "makeWideIntAddSub(WideIntAddSubOp::AddInt128)"),
     ("i64.sub128",     "makeWideIntAddSub(WideIntAddSubOp::SubInt128)"),
+    ("i64.mul_wide_s", "makeWideIntMul(WideIntMulOp::MulWideSInt64)"),
+    ("i64.mul_wide_u", "makeWideIntMul(WideIntMulOp::MulWideUInt64)"),
     ("f32.abs",        "makeUnary(UnaryOp::AbsFloat32)"),
     ("f32.neg",        "makeUnary(UnaryOp::NegFloat32)"),
     ("f32.ceil",       "makeUnary(UnaryOp::CeilFloat32)"),
diff --git a/scripts/test/shared.py b/scripts/test/shared.py
@@ -403,7 +403,6 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'threads/atomic.wast',
 ]
 SPEC_TESTSUITE_PROPOSALS_TO_SKIP = [
-    'wide-arithmetic',
 ]
 
 # Paths are relative to the test/spec/testsuite directory
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -3969,12 +3969,34 @@ switch (buf[0]) {
                   default: goto parse_error;
                 }
               }
-              case 'm':
-                if (op == "i64.mul"sv) {
-                  CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt64));
-                  return Ok{};
+              case 'm': {
+                switch (buf[7]) {
+                  case '\0':
+                    if (op == "i64.mul"sv) {
+                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt64));
+                      return Ok{};
+                    }
+                    goto parse_error;
+                  case '_': {
+                    switch (buf[13]) {
+                      case 's':
+                        if (op == "i64.mul_wide_s"sv) {
+                          CHECK_ERR(makeWideIntMul(ctx, pos, annotations, WideIntMulOp::MulWideSInt64));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      case 'u':
+                        if (op == "i64.mul_wide_u"sv) {
+                          CHECK_ERR(makeWideIntMul(ctx, pos, annotations, WideIntMulOp::MulWideUInt64));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  default: goto parse_error;
                 }
-                goto parse_error;
+              }
               case 'n':
                 if (op == "i64.ne"sv) {
                   CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeInt64));
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -217,6 +217,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
     }
   }
   Flow visitWideIntAddSub(WideIntAddSub* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitWideIntMul(WideIntMul* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitDrop(Drop* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitReturn(Return* curr) { WASM_UNREACHABLE("TODO"); }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -110,6 +110,7 @@ void ReFinalize::visitConst(Const* curr) { curr->finalize(); }
 void ReFinalize::visitUnary(Unary* curr) { curr->finalize(); }
 void ReFinalize::visitBinary(Binary* curr) { curr->finalize(); }
 void ReFinalize::visitWideIntAddSub(WideIntAddSub* curr) { curr->finalize(); }
+void ReFinalize::visitWideIntMul(WideIntMul* curr) { curr->finalize(); }
 void ReFinalize::visitSelect(Select* curr) { curr->finalize(); }
 void ReFinalize::visitDrop(Drop* curr) { curr->finalize(); }
 void ReFinalize::visitReturn(Return* curr) { curr->finalize(); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -710,6 +710,11 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->rightHigh, Type::i64);
   }
 
+  void visitWideIntMul(WideIntMul* curr) {
+    note(&curr->left, Type::i64);
+    note(&curr->right, Type::i64);
+  }
+
   void visitSelect(Select* curr, std::optional<Type> type = std::nullopt) {
     if (type) {
       note(&curr->ifTrue, *type);
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -577,6 +577,9 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return 1 + visit(curr->leftLow) + visit(curr->leftHigh) +
            visit(curr->rightLow) + visit(curr->rightHigh);
   }
+  CostType visitWideIntMul(WideIntMul* curr) {
+    return 1 + visit(curr->left) + visit(curr->right);
+  }
   CostType visitSelect(Select* curr) {
     return 1 + visit(curr->condition) + visit(curr->ifTrue) +
            visit(curr->ifFalse);
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -946,6 +946,7 @@ class EffectAnalyzer {
       }
     }
     void visitWideIntAddSub(WideIntAddSub* curr) {}
+    void visitWideIntMul(WideIntMul* curr) {}
     void visitSelect(Select* curr) {}
     void visitDrop(Drop* curr) {}
     void visitReturn(Return* curr) { parent.branchesOut = true; }
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -635,6 +635,7 @@ struct InfoCollector
   }
   void visitBinary(Binary* curr) { addRoot(curr); }
   void visitWideIntAddSub(WideIntAddSub* curr) { addRoot(curr); }
+  void visitWideIntMul(WideIntMul* curr) { addRoot(curr); }
   void visitSelect(Select* curr) {
     receiveChildValue(curr->ifTrue, curr);
     receiveChildValue(curr->ifFalse, curr);
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -214,6 +214,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
   void visitWideIntAddSub(WideIntAddSub* curr) {}
+  void visitWideIntMul(WideIntMul* curr) {}
   void visitSelect(Select* curr) {
     self()->noteSubtype(curr->ifTrue, curr);
     self()->noteSubtype(curr->ifFalse, curr);
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -481,6 +481,10 @@ struct NullInstrParserCtx {
     return Ok{};
   }
 
+  Result<> makeWideIntMul(Index, const std::vector<Annotation>&, WideIntMulOp) {
+    return Ok{};
+  }
+
   Result<> makeUnary(Index, const std::vector<Annotation>&, UnaryOp) {
     return Ok{};
   }
@@ -2170,6 +2174,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeWideIntAddSub(op));
   }
 
+  Result<> makeWideIntMul(Index pos,
+                          const std::vector<Annotation>& annotations,
+                          WideIntMulOp op) {
+    return withLoc(pos, irBuilder.makeWideIntMul(op));
+  }
+
   Result<>
   makeUnary(Index pos, const std::vector<Annotation>& annotations, UnaryOp op) {
     return withLoc(pos, irBuilder.makeUnary(op));
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -96,6 +96,9 @@ Result<> makeWideIntAddSub(Ctx&,
                            const std::vector<Annotation>&,
                            WideIntAddSubOp op);
 template<typename Ctx>
+Result<>
+makeWideIntMul(Ctx&, Index, const std::vector<Annotation>&, WideIntMulOp op);
+template<typename Ctx>
 Result<> makeUnary(Ctx&, Index, const std::vector<Annotation>&, UnaryOp op);
 template<typename Ctx>
 Result<> makeSelect(Ctx&, Index, const std::vector<Annotation>&);
@@ -1605,6 +1608,14 @@ Result<> makeWideIntAddSub(Ctx& ctx,
   return ctx.makeWideIntAddSub(pos, annotations, op);
 }
 
+template<typename Ctx>
+Result<> makeWideIntMul(Ctx& ctx,
+                        Index pos,
+                        const std::vector<Annotation>& annotations,
+                        WideIntMulOp op) {
+  return ctx.makeWideIntMul(pos, annotations, op);
+}
+
 template<typename Ctx>
 Result<> makeUnary(Ctx& ctx,
                    Index pos,
diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp
@@ -1557,6 +1557,10 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     WASM_UNREACHABLE("TODO: wide arithmetic lowering");
   }
 
+  void visitWideIntMul(WideIntMul* curr) {
+    WASM_UNREACHABLE("TODO: wide arithmetic lowering");
+  }
+
   void visitSelect(Select* curr) {
     if (handleUnreachable(curr)) {
       return;
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2039,6 +2039,20 @@ struct PrintExpressionContents
     }
     restoreNormalColor(o);
   }
+  void visitWideIntMul(WideIntMul* curr) {
+    prepareColor(o);
+    switch (curr->op) {
+      case MulWideSInt64: {
+        o << "i64.mul_wide_s";
+        break;
+      }
+      case MulWideUInt64: {
+        o << "i64.mul_wide_u";
+        break;
+      }
+    }
+    restoreNormalColor(o);
+  }
   void visitSelect(Select* curr) {
     prepareColor(o) << "select";
     restoreNormalColor(o);
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -434,6 +434,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
   void visitWideIntAddSub(WideIntAddSub* curr) {}
+  void visitWideIntMul(WideIntMul* curr) {}
 
   void visitSelect(Select* curr) {
     if (curr->type.isRef()) {
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1140,6 +1140,8 @@ enum ASTNodes {
 
   I64Add128 = 0x13,
   I64Sub128 = 0x14,
+  I64MulWideS = 0x15,
+  I64MulWideU = 0x16,
 
   // reference types opcodes
 
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -674,6 +674,16 @@ class Builder {
     ret->finalize();
     return ret;
   }
+
+  WideIntMul*
+  makeWideIntMul(WideIntMulOp op, Expression* left, Expression* right) {
+    auto* ret = wasm.allocator.alloc<WideIntMul>();
+    ret->op = op;
+    ret->left = left;
+    ret->right = right;
+    ret->finalize();
+    return ret;
+  }
   Select*
   makeSelect(Expression* condition, Expression* ifTrue, Expression* ifFalse) {
     auto* ret = wasm.allocator.alloc<Select>();
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -939,6 +939,12 @@ DELEGATE_FIELD_CHILD(WideIntAddSub, leftHigh)
 DELEGATE_FIELD_CHILD(WideIntAddSub, leftLow)
 DELEGATE_FIELD_CASE_END(WideIntAddSub)
 
+DELEGATE_FIELD_CASE_START(WideIntMul)
+DELEGATE_FIELD_INT(WideIntMul, op)
+DELEGATE_FIELD_CHILD(WideIntMul, right)
+DELEGATE_FIELD_CHILD(WideIntMul, left)
+DELEGATE_FIELD_CASE_END(WideIntMul)
+
 DELEGATE_FIELD_MAIN_END
 
 #undef DELEGATE_ID
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -120,5 +120,6 @@ DELEGATE(StackSwitch);
 DELEGATE(StructWait);
 DELEGATE(StructNotify);
 DELEGATE(WideIntAddSub);
+DELEGATE(WideIntMul);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1831,6 +1831,63 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     }
     WASM_UNREACHABLE("invalid wide int binary op");
   }
+  Flow visitWideIntMul(WideIntMul* curr) {
+    VISIT(left, curr->left);
+    VISIT(right, curr->right);
+    uint64_t lhs = left.getSingleValue().geti64();
+    uint64_t rhs = right.getSingleValue().geti64();
+
+    uint64_t lowResult = 0;
+    uint64_t highResult = 0;
+
+#ifdef __SIZEOF_INT128__
+    if (curr->op == MulWideSInt64) {
+      __int128 result = (__int128)(int64_t)lhs * (__int128)(int64_t)rhs;
+      lowResult = (uint64_t)result;
+      highResult = (uint64_t)(result >> 64);
+    } else {
+      unsigned __int128 result =
+        (unsigned __int128)lhs * (unsigned __int128)rhs;
+      lowResult = (uint64_t)result;
+      highResult = (uint64_t)(result >> 64);
+    }
+#else
+    uint64_t uLhs = lhs;
+    uint64_t uRhs = rhs;
+
+    uint64_t u1 = uLhs & 0xffffffff;
+    uint64_t v1 = uRhs & 0xffffffff;
+    uint64_t t = (u1 * v1);
+    uint64_t w3 = t & 0xffffffff;
+    uint64_t k = t >> 32;
+
+    uLhs >>= 32;
+    t = (uLhs * v1) + k;
+    k = t & 0xffffffff;
+    uint64_t w1 = t >> 32;
+
+    uRhs >>= 32;
+    t = (u1 * uRhs) + k;
+    k = t >> 32;
+
+    highResult = (uLhs * uRhs) + w1 + k;
+    lowResult = (t << 32) + w3;
+
+    if (curr->op == MulWideSInt64) {
+      if ((int64_t)lhs < 0) {
+        highResult -= rhs;
+      }
+      if ((int64_t)rhs < 0) {
+        highResult -= lhs;
+      }
+    }
+#endif
+
+    Literals results;
+    results.push_back(Literal(lowResult));
+    results.push_back(Literal(highResult));
+    return results;
+  }
   Flow visitDrop(Drop* curr) {
     VISIT(value, curr->value)
     return Flow();
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -191,6 +191,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeUnary(UnaryOp op);
   Result<> makeBinary(BinaryOp op);
   Result<> makeWideIntAddSub(WideIntAddSubOp op);
+  Result<> makeWideIntMul(WideIntMulOp op);
   Result<> makeSelect(std::optional<Type> type = std::nullopt);
   Result<> makeDrop();
   Result<> makeReturn();
diff --git a/src/wasm.h b/src/wasm.h
@@ -643,6 +643,11 @@ enum WideIntAddSubOp {
   SubInt128,
 };
 
+enum WideIntMulOp {
+  MulWideSInt64,
+  MulWideUInt64,
+};
+
 //
 // Expressions
 //
@@ -773,6 +778,7 @@ class Expression {
     StructWaitId,
     StructNotifyId,
     WideIntAddSubId,
+    WideIntMulId,
     NumExpressionIds
   };
   Id _id;
@@ -1318,6 +1324,18 @@ class WideIntAddSub : public SpecificExpression<Expression::WideIntAddSubId> {
   void finalize();
 };
 
+class WideIntMul : public SpecificExpression<Expression::WideIntMulId> {
+public:
+  WideIntMul() = default;
+  WideIntMul(MixedArena& allocator) {}
+
+  WideIntMulOp op;
+  Expression* left;
+  Expression* right;
+
+  void finalize();
+};
+
 class Select : public SpecificExpression<Expression::SelectId> {
 public:
   Select() = default;
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -4002,6 +4002,10 @@ Result<> WasmBinaryReader::readInst() {
           return builder.makeWideIntAddSub(AddInt128);
         case BinaryConsts::I64Sub128:
           return builder.makeWideIntAddSub(SubInt128);
+        case BinaryConsts::I64MulWideS:
+          return builder.makeWideIntMul(MulWideSInt64);
+        case BinaryConsts::I64MulWideU:
+          return builder.makeWideIntMul(MulWideUInt64);
         case BinaryConsts::TableSize:
           return builder.makeTableSize(getTableName(getU32LEB()));
         case BinaryConsts::TableGrow:
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -1766,6 +1766,14 @@ Result<> IRBuilder::makeWideIntAddSub(WideIntAddSubOp op) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeWideIntMul(WideIntMulOp op) {
+  WideIntMul curr;
+  curr.op = op;
+  CHECK_ERR(visitWideIntMul(&curr));
+  push(builder.makeWideIntMul(op, curr.left, curr.right));
+  return Ok{};
+}
+
 Result<> IRBuilder::makeSelect(std::optional<Type> type) {
   Select curr;
   CHECK_ERR(visitSelect(&curr));
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
diff --git a/src/wasm2js.h b/src/wasm2js.h
diff --git a/test/spec/wide-arithmetic.wast b/test/spec/wide-arithmetic.wast

Original file line number	Diff line number	Diff line change
`@@ -403,7 +403,6 @@ def get_tests(test_dir, extensions=[], recursive=False):`
`403`	`403`	`'threads/atomic.wast',`
`404`	`404`	`]`
`405`	`405`	`SPEC_TESTSUITE_PROPOSALS_TO_SKIP = [`
`406`		`- 'wide-arithmetic',`
`407`	`406`	`]`
`408`	`407`
`409`	`408`	`# Paths are relative to the test/spec/testsuite directory`
Original file line number	Diff line number	Diff line change
`@@ -217,6 +217,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`Flow visitWideIntAddSub(WideIntAddSub* curr) { WASM_UNREACHABLE("TODO"); }`
	`220`	`+ Flow visitWideIntMul(WideIntMul* curr) { WASM_UNREACHABLE("TODO"); }`
`220`	`221`	`Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }`
`221`	`222`	`Flow visitDrop(Drop* curr) { WASM_UNREACHABLE("TODO"); }`
`222`	`223`	`Flow visitReturn(Return* curr) { WASM_UNREACHABLE("TODO"); }`
Original file line number	Diff line number	Diff line change
`@@ -946,6 +946,7 @@ class EffectAnalyzer {`
`946`	`946`	`}`
`947`	`947`	`}`
`948`	`948`	`void visitWideIntAddSub(WideIntAddSub* curr) {}`
	`949`	`+ void visitWideIntMul(WideIntMul* curr) {}`
`949`	`950`	`void visitSelect(Select* curr) {}`
`950`	`951`	`void visitDrop(Drop* curr) {}`
`951`	`952`	`void visitReturn(Return* curr) { parent.branchesOut = true; }`