Support i64.add/sub128 instructions from Wide Arithmetic proposal (#8638)

stevenfontanella · web-flow · commit c6a5e65b77a4 · 2026-04-28T23:57:13.000Z
Part of #8544 i64 to i32 lowering isn't implemented yet because supporting multi-value i64 returns requires more work here. Will add this in a separate change. Spec tests are adapted from the upstream proposal repo, with only tests related to i64.add128 and i64.sub128 included. Drive-by changes: * Remove unneeded template params in wasm-validator.cpp * Unconditionally assign to the result in ckd_add / ckd_sub polyfills to match the behavior of the [std implementations](https://en.cppreference.com/cpp/numeric/ckd_add). All of the existing callers don't observe the result when overflow occurred, but for our case we need the value regardless.
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -148,6 +148,8 @@
     ("i64.shr_u",      "makeBinary(BinaryOp::ShrUInt64)"),
     ("i64.rotl",       "makeBinary(BinaryOp::RotLInt64)"),
     ("i64.rotr",       "makeBinary(BinaryOp::RotRInt64)"),
+    ("i64.add128",     "makeWideIntAddSub(WideIntAddSubOp::AddInt128)"),
+    ("i64.sub128",     "makeWideIntAddSub(WideIntAddSubOp::SubInt128)"),
     ("f32.abs",        "makeUnary(UnaryOp::AbsFloat32)"),
     ("f32.neg",        "makeUnary(UnaryOp::NegFloat32)"),
     ("f32.ceil",       "makeUnary(UnaryOp::CeilFloat32)"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -3427,12 +3427,23 @@ switch (buf[0]) {
             switch (buf[4]) {
               case 'a': {
                 switch (buf[5]) {
-                  case 'd':
-                    if (op == "i64.add"sv) {
-                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt64));
-                      return Ok{};
+                  case 'd': {
+                    switch (buf[7]) {
+                      case '\0':
+                        if (op == "i64.add"sv) {
+                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt64));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      case '1':
+                        if (op == "i64.add128"sv) {
+                          CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::AddInt128));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      default: goto parse_error;
                     }
-                    goto parse_error;
+                  }
                   case 'n':
                     if (op == "i64.and"sv) {
                       CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndInt64));
@@ -4113,12 +4124,23 @@ switch (buf[0]) {
                       default: goto parse_error;
                     }
                   }
-                  case 'u':
-                    if (op == "i64.sub"sv) {
-                      CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt64));
-                      return Ok{};
+                  case 'u': {
+                    switch (buf[7]) {
+                      case '\0':
+                        if (op == "i64.sub"sv) {
+                          CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt64));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      case '1':
+                        if (op == "i64.sub128"sv) {
+                          CHECK_ERR(makeWideIntAddSub(ctx, pos, annotations, WideIntAddSubOp::SubInt128));
+                          return Ok{};
+                        }
+                        goto parse_error;
+                      default: goto parse_error;
                     }
-                    goto parse_error;
+                  }
                   default: goto parse_error;
                 }
               }
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -216,6 +216,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
         WASM_UNREACHABLE("TODO");
     }
   }
+  Flow visitWideIntAddSub(WideIntAddSub* 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
@@ -109,6 +109,7 @@ void ReFinalize::visitMemoryFill(MemoryFill* curr) { curr->finalize(); }
 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::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
@@ -705,6 +705,13 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
   }
 
+  void visitWideIntAddSub(WideIntAddSub* curr) {
+    note(&curr->leftLow, Type::i64);
+    note(&curr->leftHigh, Type::i64);
+    note(&curr->rightLow, Type::i64);
+    note(&curr->rightHigh, 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
@@ -575,6 +575,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     }
     return ret + visit(curr->left) + visit(curr->right);
   }
+  CostType visitWideIntAddSub(WideIntAddSub* curr) {
+    return 1 + visit(curr->leftLow) + visit(curr->leftHigh) +
+           visit(curr->rightLow) + visit(curr->rightHigh);
+  }
   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
@@ -945,6 +945,7 @@ class EffectAnalyzer {
         }
       }
     }
+    void visitWideIntAddSub(WideIntAddSub* 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
@@ -634,6 +634,7 @@ struct InfoCollector
     addRoot(curr);
   }
   void visitBinary(Binary* curr) { addRoot(curr); }
+  void visitWideIntAddSub(WideIntAddSub* 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
@@ -213,6 +213,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitConst(Const* curr) {}
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
+  void visitWideIntAddSub(WideIntAddSub* 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
@@ -476,6 +476,11 @@ struct NullInstrParserCtx {
   Result<> makeBinary(Index, const std::vector<Annotation>&, BinaryOp) {
     return Ok{};
   }
+  Result<>
+  makeWideIntAddSub(Index, const std::vector<Annotation>&, WideIntAddSubOp) {
+    return Ok{};
+  }
+
   Result<> makeUnary(Index, const std::vector<Annotation>&, UnaryOp) {
     return Ok{};
   }
@@ -2159,6 +2164,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeBinary(op));
   }
 
+  Result<> makeWideIntAddSub(Index pos,
+                             const std::vector<Annotation>& annotations,
+                             WideIntAddSubOp op) {
+    return withLoc(pos, irBuilder.makeWideIntAddSub(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
@@ -91,6 +91,11 @@ Result<> makeNop(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeBinary(Ctx&, Index, const std::vector<Annotation>&, BinaryOp op);
 template<typename Ctx>
+Result<> makeWideIntAddSub(Ctx&,
+                           Index,
+                           const std::vector<Annotation>&,
+                           WideIntAddSubOp 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>&);
@@ -1592,6 +1597,14 @@ Result<> makeBinary(Ctx& ctx,
   return ctx.makeBinary(pos, annotations, op);
 }
 
+template<typename Ctx>
+Result<> makeWideIntAddSub(Ctx& ctx,
+                           Index pos,
+                           const std::vector<Annotation>& annotations,
+                           WideIntAddSubOp op) {
+  return ctx.makeWideIntAddSub(pos, annotations, op);
+}
+
 template<typename Ctx>
 Result<> makeUnary(Ctx& ctx,
                    Index pos,
diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp
@@ -1553,6 +1553,10 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     }
   }
 
+  void visitWideIntAddSub(WideIntAddSub* 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
@@ -2031,6 +2031,20 @@ struct PrintExpressionContents
     }
     restoreNormalColor(o);
   }
+  void visitWideIntAddSub(WideIntAddSub* curr) {
+    prepareColor(o);
+    switch (curr->op) {
+      case AddInt128: {
+        o << "i64.add128";
+        break;
+      }
+      case SubInt128: {
+        o << "i64.sub128";
+        break;
+      }
+    }
+    restoreNormalColor(o);
+  }
   void visitSelect(Select* curr) {
     prepareColor(o) << "select";
     restoreNormalColor(o);
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -433,6 +433,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitConst(Const* curr) {}
   void visitUnary(Unary* curr) {}
   void visitBinary(Binary* curr) {}
+  void visitWideIntAddSub(WideIntAddSub* curr) {}
 
   void visitSelect(Select* curr) {
     if (curr->type.isRef()) {
diff --git a/src/support/stdckdint.h b/src/support/stdckdint.h
@@ -29,12 +29,20 @@ template<typename T> bool ckd_add(T* output, T a, T b) {
   // Atm this polyfill only supports unsigned types.
   static_assert(std::is_unsigned_v<T>);
 
-  T result = a + b;
-  if (result < a) {
-    return true;
-  }
-  *output = result;
-  return false;
+  *output = a + b;
+  return *output < a;
+#endif
+}
+
+template<typename T> bool ckd_sub(T* output, T a, T b) {
+#if __has_builtin(__builtin_sub_overflow)
+  return __builtin_sub_overflow(a, b, output);
+#else
+  // Atm this polyfill only supports unsigned types.
+  static_assert(std::is_unsigned_v<T>);
+
+  *output = a - b;
+  return *output > a;
 #endif
 }
 
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1138,6 +1138,11 @@ enum ASTNodes {
   MemoryCopy = 0x0a,
   MemoryFill = 0x0b,
 
+  // wide arithmetic opcodes
+
+  I64Add128 = 0x13,
+  I64Sub128 = 0x14,
+
   // reference types opcodes
 
   TableGrow = 0x0f,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -660,6 +660,20 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  WideIntAddSub* makeWideIntAddSub(WideIntAddSubOp op,
+                                   Expression* leftLow,
+                                   Expression* leftHigh,
+                                   Expression* rightLow,
+                                   Expression* rightHigh) {
+    auto* ret = wasm.allocator.alloc<WideIntAddSub>();
+    ret->op = op;
+    ret->leftLow = leftLow;
+    ret->leftHigh = leftHigh;
+    ret->rightLow = rightLow;
+    ret->rightHigh = rightHigh;
+    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
@@ -931,6 +931,13 @@ DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructNotify, ref)
 DELEGATE_FIELD_INT(StructNotify, index)
 DELEGATE_FIELD_CASE_END(StructNotify)
 
+DELEGATE_FIELD_CASE_START(WideIntAddSub)
+DELEGATE_FIELD_INT(WideIntAddSub, op)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightHigh)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightLow)
+DELEGATE_FIELD_CHILD(WideIntAddSub, leftHigh)
+DELEGATE_FIELD_CHILD(WideIntAddSub, leftLow)
+DELEGATE_FIELD_CASE_END(WideIntAddSub)
 
 DELEGATE_FIELD_MAIN_END
 
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -119,5 +119,6 @@ DELEGATE(ResumeThrow);
 DELEGATE(StackSwitch);
 DELEGATE(StructWait);
 DELEGATE(StructNotify);
+DELEGATE(WideIntAddSub);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1801,6 +1801,38 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(condition, curr->condition)
     return condition.getSingleValue().geti32() ? ifTrue : ifFalse; // ;-)
   }
+  Flow visitWideIntAddSub(WideIntAddSub* curr) {
+    VISIT(leftLow, curr->leftLow);
+    VISIT(leftHigh, curr->leftHigh);
+    VISIT(rightLow, curr->rightLow);
+    VISIT(rightHigh, curr->rightHigh);
+
+    uint64_t lowLHS = leftLow.getSingleValue().geti64();
+    uint64_t highLHS = leftHigh.getSingleValue().geti64();
+    uint64_t lowRHS = rightLow.getSingleValue().geti64();
+    uint64_t highRHS = rightHigh.getSingleValue().geti64();
+
+    uint64_t lowResult = 0;
+    uint64_t highResult = 0;
+
+    switch (curr->op) {
+      case AddInt128: {
+        bool overflowed = std::ckd_add(&lowResult, lowLHS, lowRHS);
+        highResult = highLHS + highRHS + overflowed;
+        break;
+      }
+      case SubInt128: {
+        bool overflowed = std::ckd_sub(&lowResult, lowLHS, lowRHS);
+        highResult = highLHS - highRHS - overflowed;
+        break;
+      }
+    }
+
+    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
@@ -190,6 +190,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeConst(Literal val);
   Result<> makeUnary(UnaryOp op);
   Result<> makeBinary(BinaryOp op);
+  Result<> makeWideIntAddSub(WideIntAddSubOp op);
   Result<> makeSelect(std::optional<Type> type = std::nullopt);
   Result<> makeDrop();
   Result<> makeReturn();
diff --git a/src/wasm-type.h b/src/wasm-type.h
@@ -645,6 +645,8 @@ constexpr HeapType noexn = HeapType::noexn;
 HeapType getMutI8Array();
 HeapType getMutI16Array();
 
+Type getI64Pair();
+
 } // namespace HeapTypes
 
 // A recursion group consisting of one or more HeapTypes. HeapTypes with single
diff --git a/src/wasm.h b/src/wasm.h
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.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
`@@ -216,6 +216,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {`
`216`	`216`	`WASM_UNREACHABLE("TODO");`
`217`	`217`	`}`
`218`	`218`	`}`
	`219`	`+ Flow visitWideIntAddSub(WideIntAddSub* curr) { WASM_UNREACHABLE("TODO"); }`
`219`	`220`	`Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }`
`220`	`221`	`Flow visitDrop(Drop* curr) { WASM_UNREACHABLE("TODO"); }`
`221`	`222`	`Flow visitReturn(Return* curr) { WASM_UNREACHABLE("TODO"); }`
Original file line number	Diff line number	Diff line change
`@@ -705,6 +705,13 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {`
`705`	`705`	`}`
`706`	`706`	`}`
`707`	`707`
	`708`	`+ void visitWideIntAddSub(WideIntAddSub* curr) {`
	`709`	`+ note(&curr->leftLow, Type::i64);`
	`710`	`+ note(&curr->leftHigh, Type::i64);`
	`711`	`+ note(&curr->rightLow, Type::i64);`
	`712`	`+ note(&curr->rightHigh, Type::i64);`
	`713`	`+ }`
	`714`	`+`
`708`	`715`	`void visitSelect(Select* curr, std::optional<Type> type = std::nullopt) {`
`709`	`716`	`if (type) {`
`710`	`717`	`note(&curr->ifTrue, *type);`
Original file line number	Diff line number	Diff line change
`@@ -575,6 +575,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`575`	`575`	`}`
`576`	`576`	`return ret + visit(curr->left) + visit(curr->right);`
`577`	`577`	`}`
	`578`	`+ CostType visitWideIntAddSub(WideIntAddSub* curr) {`
	`579`	`+ return 1 + visit(curr->leftLow) + visit(curr->leftHigh) +`
	`580`	`+ visit(curr->rightLow) + visit(curr->rightHigh);`
	`581`	`+ }`
`578`	`582`	`CostType visitSelect(Select* curr) {`
`579`	`583`	`return 1 + visit(curr->condition) + visit(curr->ifTrue) +`
`580`	`584`	`visit(curr->ifFalse);`
Original file line number	Diff line number	Diff line change
`@@ -945,6 +945,7 @@ class EffectAnalyzer {`
`945`	`945`	`}`
`946`	`946`	`}`
`947`	`947`	`}`
	`948`	`+ void visitWideIntAddSub(WideIntAddSub* curr) {}`
`948`	`949`	`void visitSelect(Select* curr) {}`
`949`	`950`	`void visitDrop(Drop* curr) {}`
`950`	`951`	`void visitReturn(Return* curr) { parent.branchesOut = true; }`
Original file line number	Diff line number	Diff line change
`@@ -634,6 +634,7 @@ struct InfoCollector`
`634`	`634`	`addRoot(curr);`
`635`	`635`	`}`
`636`	`636`	`void visitBinary(Binary* curr) { addRoot(curr); }`
	`637`	`+ void visitWideIntAddSub(WideIntAddSub* curr) { addRoot(curr); }`
`637`	`638`	`void visitSelect(Select* curr) {`
`638`	`639`	`receiveChildValue(curr->ifTrue, curr);`
`639`	`640`	`receiveChildValue(curr->ifFalse, curr);`