From 9f98b32cfce4a84e2b9b116f6455541fa32c4b51 Mon Sep 17 00:00:00 2001
From: stevenfontanella <stevenfont@chromium.org>
Date: Tue, 14 Apr 2026 22:10:26 +0000
Subject: [PATCH 1/4] Support for wide arithmetic

---
 scripts/gen-s-parser.py         |   2 +
 src/gen-s-parser.inc            |  42 +++--
 src/interpreter/interpreter.cpp |   1 +
 src/ir/ReFinalize.cpp           |   1 +
 src/ir/child-typer.h            |   7 +
 src/ir/cost.h                   |   4 +
 src/ir/effects.h                |   1 +
 src/ir/possible-contents.cpp    |   1 +
 src/ir/subtype-exprs.h          |   1 +
 src/parser/contexts.h           |  11 ++
 src/parser/parsers.h            |  13 ++
 src/passes/I64ToI32Lowering.cpp |   4 +
 src/passes/Print.cpp            |  14 ++
 src/passes/TypeGeneralizing.cpp |   1 +
 src/support/stdckdint.h         |  20 ++-
 src/wasm-binary.h               |   5 +
 src/wasm-builder.h              |  14 ++
 src/wasm-delegations-fields.def |   7 +
 src/wasm-delegations.def        |   1 +
 src/wasm-interpreter.h          |  34 ++++
 src/wasm-ir-builder.h           |   1 +
 src/wasm.h                      |  20 +++
 src/wasm/wasm-binary.cpp        |   4 +
 src/wasm/wasm-ir-builder.cpp    |   9 +
 src/wasm/wasm-stack.cpp         |  14 ++
 src/wasm/wasm-validator.cpp     |  28 ++-
 src/wasm/wasm.cpp               |  11 ++
 src/wasm2js.h                   |   4 +
 test/spec/wide-arithmetic.wast  | 310 ++++++++++++++++++++++++++++++++
 29 files changed, 564 insertions(+), 21 deletions(-)
 create mode 100644 test/spec/wide-arithmetic.wast

diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index b2a2573c4e4..d8ebce98e31 100755
--- 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
index 345afa302aa..d3d3b99a702 100644
--- 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
index d15abcfd4a0..e3abe63525d 100644
--- 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
index 24afae568c5..6c722cbb03c 100644
--- 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
index e223eb2ad59..2aa1a06d549 100644
--- 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
index 7c02dafce7b..7d044a49947 100644
--- 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
index af866b9e536..ec96053a13d 100644
--- 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
index 4dc6da9c9d9..08cf1cf4f8d 100644
--- 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
index 8a4677ec9da..b0a910f3fa7 100644
--- 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
index 88b7d8a941c..e62d3d5869a 100644
--- 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
index 4a5fb71b771..c0d2804e29f 100644
--- 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
index 42feafa3861..0724b448674 100644
--- 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
index 8239edc71be..c926c914720 100644
--- 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
index 03a0a0f11a7..1cd9a1b7885 100644
--- 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
index 42e87f9a26d..c5132058332 100644
--- 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
index 82363964d0b..85458e97a3b 100644
--- 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
index 30465e9e128..cd9d0c34ddd 100644
--- 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
index 432f4d832c9..f8228f33203 100644
--- 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, leftLow)
+DELEGATE_FIELD_CHILD(WideIntAddSub, leftHigh)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightLow)
+DELEGATE_FIELD_CHILD(WideIntAddSub, rightHigh)
+DELEGATE_FIELD_CASE_END(WideIntAddSub)
 
 DELEGATE_FIELD_MAIN_END
 
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
index eb7dfe84afb..92572b01198 100644
--- 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
index a57f05ea66f..14e8f8e5af4 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1801,6 +1801,40 @@ 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);
+    if (curr->op == AddInt128 || curr->op == SubInt128) {
+      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;
+    }
+    WASM_UNREACHABLE("invalid wide int binary op");
+  }
   Flow visitDrop(Drop* curr) {
     VISIT(value, curr->value)
     return Flow();
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 92b8a8acfb1..9b87cba55e2 100644
--- 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.h b/src/wasm.h
index e59f99633f5..be7904bb674 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -640,6 +640,11 @@ enum StringEqOp {
   StringEqCompare,
 };
 
+enum WideIntAddSubOp {
+  AddInt128,
+  SubInt128,
+};
+
 //
 // Expressions
 //
@@ -769,6 +774,7 @@ class Expression {
     StackSwitchId,
     StructWaitId,
     StructNotifyId,
+    WideIntAddSubId,
     NumExpressionIds
   };
   Id _id;
@@ -1300,6 +1306,20 @@ class Binary : public SpecificExpression<Expression::BinaryId> {
   void finalize();
 };
 
+class WideIntAddSub : public SpecificExpression<Expression::WideIntAddSubId> {
+public:
+  WideIntAddSub() = default;
+  WideIntAddSub(MixedArena& allocator) {}
+
+  WideIntAddSubOp op;
+  Expression* leftLow;
+  Expression* leftHigh;
+  Expression* rightLow;
+  Expression* rightHigh;
+
+  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
index d5665fa48ec..368203ba5ff 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -3998,6 +3998,10 @@ Result<> WasmBinaryReader::readInst() {
         }
         case BinaryConsts::MemoryFill:
           return builder.makeMemoryFill(getMemoryName(getU32LEB()));
+        case BinaryConsts::I64Add128:
+          return builder.makeWideIntAddSub(AddInt128);
+        case BinaryConsts::I64Sub128:
+          return builder.makeWideIntAddSub(SubInt128);
         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
index 903e8e87167..be6148496c0 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -1757,6 +1757,15 @@ Result<> IRBuilder::makeBinary(BinaryOp op) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeWideIntAddSub(WideIntAddSubOp op) {
+  WideIntAddSub curr;
+  curr.op = op;
+  CHECK_ERR(visitWideIntAddSub(&curr));
+  push(builder.makeWideIntAddSub(
+    op, curr.leftLow, curr.leftHigh, curr.rightLow, curr.rightHigh));
+  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
index cc865b0189d..93521cb1e26 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2295,6 +2295,20 @@ void BinaryInstWriter::visitSelect(Select* curr) {
   }
 }
 
+void BinaryInstWriter::visitWideIntAddSub(WideIntAddSub* curr) {
+  o << static_cast<int8_t>(BinaryConsts::MiscPrefix);
+  switch (curr->op) {
+    case AddInt128: {
+      o << U32LEB(BinaryConsts::I64Add128);
+      break;
+    }
+    case SubInt128: {
+      o << U32LEB(BinaryConsts::I64Sub128);
+      break;
+    }
+  }
+}
+
 void BinaryInstWriter::visitReturn(Return* curr) {
   o << static_cast<int8_t>(BinaryConsts::Return);
 }
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index 3e809d0157d..7ad1281ea31 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -173,9 +173,9 @@ struct ValidationInfo {
     return true;
   }
 
-  template<typename T, typename S>
+  template<typename T>
   bool shouldBeEqualOrFirstIsUnreachable(
-    S left, S right, T curr, const char* text, Function* func = nullptr) {
+    Type left, Type right, T curr, const char* text, Function* func = nullptr) {
     if (left != Type::unreachable && left != right) {
       std::ostringstream ss;
       ss << left << " != " << right << ": " << text;
@@ -508,6 +508,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitMemoryCopy(MemoryCopy* curr);
   void visitMemoryFill(MemoryFill* curr);
   void visitBinary(Binary* curr);
+  void visitWideIntAddSub(WideIntAddSub* curr);
   void visitUnary(Unary* curr);
   void visitSelect(Select* curr);
   void visitDrop(Drop* curr);
@@ -607,9 +608,11 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
     return info.shouldBeEqual(left, right, curr, text, getFunction());
   }
 
-  template<typename T, typename S>
-  bool
-  shouldBeEqualOrFirstIsUnreachable(S left, S right, T curr, const char* text) {
+  template<typename T>
+  bool shouldBeEqualOrFirstIsUnreachable(Type left,
+                                         Type right,
+                                         T curr,
+                                         const char* text) {
     return info.shouldBeEqualOrFirstIsUnreachable(
       left, right, curr, text, getFunction());
   }
@@ -2443,6 +2446,21 @@ void FunctionValidator::visitSelect(Select* curr) {
   }
 }
 
+void FunctionValidator::visitWideIntAddSub(WideIntAddSub* curr) {
+  shouldBeTrue(getModule()->features.hasWideArithmetic(),
+               curr,
+               "i64.add128 / i64.sub128 require wide arithmetic "
+               "[--enable-wide-arithmetic]");
+
+  for (auto* operand :
+       {curr->leftLow, curr->leftHigh, curr->rightLow, curr->rightHigh}) {
+    shouldBeEqualOrFirstIsUnreachable(operand->type,
+                                      Type(Type::BasicType::i64),
+                                      curr,
+                                      "wide binary child types must be i64");
+  }
+}
+
 void FunctionValidator::visitDrop(Drop* curr) {
   shouldBeTrue(curr->value->type.isConcrete() ||
                  curr->value->type == Type::unreachable,
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index 9aae6cba291..abfd1ddfd05 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -803,6 +803,17 @@ void Binary::finalize() {
   }
 }
 
+void WideIntAddSub::finalize() {
+  if (leftLow->type == Type::unreachable ||
+      leftHigh->type == Type::unreachable ||
+      rightLow->type == Type::unreachable ||
+      rightHigh->type == Type::unreachable) {
+    type = Type::unreachable;
+  } else {
+    type = Type({Type::i64, Type::i64});
+  }
+}
+
 void Select::finalize() {
   assert(ifTrue && ifFalse);
   if (ifTrue->type == Type::unreachable || ifFalse->type == Type::unreachable ||
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 2de6e2287cc..735669d3d27 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -1960,6 +1960,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       return makeJsCoercion(ret, wasmToJsType(curr->type));
     }
 
+    Ref visitWideIntAddSub(WideIntAddSub* curr) {
+      WASM_UNREACHABLE("wide arithmetic is not supported by wasm2js");
+    }
+
     Ref visitSelect(Select* curr) {
       // If the condition has effects that interact with the operands, we must
       // reorder it to the start. We must also use locals if the values have
diff --git a/test/spec/wide-arithmetic.wast b/test/spec/wide-arithmetic.wast
new file mode 100644
index 00000000000..8c0cca7c368
--- /dev/null
+++ b/test/spec/wide-arithmetic.wast
@@ -0,0 +1,310 @@
+;; Ported from the upstream proposal's tests.
+;; TODO: enable the proposal's testsuite and delete this.
+
+(module
+  (func (export "i64.add128") (param i64 i64 i64 i64) (result i64 i64)
+    local.get 0
+    local.get 1
+    local.get 2
+    local.get 3
+    i64.add128)
+  (func (export "i64.sub128") (param i64 i64 i64 i64) (result i64 i64)
+    local.get 0
+    local.get 1
+    local.get 2
+    local.get 3
+    i64.sub128)
+)
+
+;; simple addition
+(assert_return (invoke "i64.add128"
+                  (i64.const 0) (i64.const 0)
+                  (i64.const 0) (i64.const 0))
+               (i64.const 0) (i64.const 0))
+(assert_return (invoke "i64.add128"
+                  (i64.const 0) (i64.const 1)
+                  (i64.const 1) (i64.const 0))
+               (i64.const 1) (i64.const 1))
+(assert_return (invoke "i64.add128"
+                  (i64.const 1) (i64.const 0)
+                  (i64.const -1) (i64.const 0))
+               (i64.const 0) (i64.const 1))
+(assert_return (invoke "i64.add128"
+                  (i64.const 1) (i64.const 1)
+                  (i64.const -1) (i64.const -1))
+               (i64.const 0) (i64.const 1))
+
+;; simple subtraction
+(assert_return (invoke "i64.sub128"
+                  (i64.const 0) (i64.const 0)
+                  (i64.const 0) (i64.const 0))
+               (i64.const 0) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 0) (i64.const 0)
+                  (i64.const 1) (i64.const 0))
+               (i64.const -1) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 0) (i64.const 1)
+                  (i64.const 1) (i64.const 1))
+               (i64.const -1) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 0) (i64.const 0)
+                  (i64.const 1) (i64.const 1))
+               (i64.const -1) (i64.const -2))
+
+;; 20 randomly generated test cases for i64.add128
+(assert_return (invoke "i64.add128"
+                   (i64.const -2418420703207364752) (i64.const -1)
+                   (i64.const -1) (i64.const -1))
+               (i64.const -2418420703207364753) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 0) (i64.const 0)
+                   (i64.const -4579433644172935106) (i64.const -1))
+               (i64.const -4579433644172935106) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 0) (i64.const 0)
+                   (i64.const 1) (i64.const -1))
+               (i64.const 1) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const 0)
+                   (i64.const 1) (i64.const 0))
+               (i64.const 2) (i64.const 0))
+(assert_return (invoke "i64.add128"
+                   (i64.const -1) (i64.const -1)
+                   (i64.const -1) (i64.const -1))
+               (i64.const -2) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 0) (i64.const -1)
+                   (i64.const 1) (i64.const 0))
+               (i64.const 1) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 0) (i64.const 0)
+                   (i64.const 0) (i64.const -1))
+               (i64.const 0) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const 0)
+                   (i64.const -1) (i64.const -1))
+               (i64.const 0) (i64.const 0))
+(assert_return (invoke "i64.add128"
+                   (i64.const 0) (i64.const 6184727276166606191)
+                   (i64.const 0) (i64.const 1))
+               (i64.const 0) (i64.const 6184727276166606192))
+(assert_return (invoke "i64.add128"
+                   (i64.const -8434911321912688222) (i64.const -1)
+                   (i64.const 1) (i64.const -1))
+               (i64.const -8434911321912688221) (i64.const -2))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const -1)
+                   (i64.const 0) (i64.const -1))
+               (i64.const 1) (i64.const -2))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const -5148941131328838092)
+                   (i64.const 0) (i64.const 0))
+               (i64.const 1) (i64.const -5148941131328838092))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const 1)
+                   (i64.const 1) (i64.const 0))
+               (i64.const 2) (i64.const 1))
+(assert_return (invoke "i64.add128"
+                   (i64.const -1) (i64.const -1)
+                   (i64.const -3636740005180858631) (i64.const -1))
+               (i64.const -3636740005180858632) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const -5529682780229988275) (i64.const -1)
+                   (i64.const 0) (i64.const 0))
+               (i64.const -5529682780229988275) (i64.const -1))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const -5381447440966559717)
+                   (i64.const 1020031372481336745) (i64.const 1))
+               (i64.const 1020031372481336746) (i64.const -5381447440966559716))
+(assert_return (invoke "i64.add128"
+                   (i64.const 1) (i64.const 1)
+                   (i64.const 0) (i64.const 0))
+               (i64.const 1) (i64.const 1))
+(assert_return (invoke "i64.add128"
+                   (i64.const -9133888546939907356) (i64.const -1)
+                   (i64.const 1) (i64.const 1))
+               (i64.const -9133888546939907355) (i64.const 0))
+(assert_return (invoke "i64.add128"
+                   (i64.const -4612047512704241719) (i64.const -1)
+                   (i64.const 0) (i64.const -1))
+               (i64.const -4612047512704241719) (i64.const -2))
+(assert_return (invoke "i64.add128"
+                   (i64.const 414720966820876428) (i64.const -1)
+                   (i64.const 1) (i64.const 0))
+               (i64.const 414720966820876429) (i64.const -1))
+
+
+;; 20 randomly generated test cases for i64.sub128
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const -2459085471354756766)
+                   (i64.const -9151153060221070927) (i64.const -1))
+               (i64.const 9151153060221070927) (i64.const -2459085471354756766))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 4566502638724063423) (i64.const -4282658540409485563)
+                   (i64.const -6884077310018979971) (i64.const -1))
+               (i64.const -6996164124966508222) (i64.const -4282658540409485563))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const 3118380319444903041)
+                   (i64.const 0) (i64.const 3283115686417695443))
+               (i64.const 1) (i64.const -164735366972792402))
+(assert_return (invoke "i64.sub128"
+                   (i64.const -7208415241680161810) (i64.const -1)
+                   (i64.const 1) (i64.const 0))
+               (i64.const -7208415241680161811) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const 3944850126731328706)
+                   (i64.const 1) (i64.const 1))
+               (i64.const -1) (i64.const 3944850126731328704))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const -1)
+                   (i64.const -1) (i64.const -1))
+               (i64.const 2) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const -1) (i64.const -1)
+                   (i64.const 4855833073346115923) (i64.const -6826437637438999645))
+               (i64.const -4855833073346115924) (i64.const 6826437637438999644))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const 0)
+                   (i64.const -1) (i64.const -1))
+               (i64.const 2) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const 0)
+                   (i64.const 1) (i64.const 0))
+               (i64.const 0) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                   (i64.const -1) (i64.const -1)
+                   (i64.const 0) (i64.const 0))
+               (i64.const -1) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const -1)
+                   (i64.const -6365475388498096428) (i64.const -1))
+               (i64.const 6365475388498096429) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 6804238617560992346) (i64.const -1)
+                   (i64.const 0) (i64.const -1))
+               (i64.const 6804238617560992346) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const 1)
+                   (i64.const 1) (i64.const -7756145513466453619))
+               (i64.const -1) (i64.const 7756145513466453619))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const -1)
+                   (i64.const 1) (i64.const 1))
+               (i64.const 0) (i64.const -2))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const 1)
+                   (i64.const 1) (i64.const 0))
+               (i64.const -1) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1) (i64.const 5602881641763648953)
+                   (i64.const -2110589244314239080) (i64.const -1))
+               (i64.const 2110589244314239081) (i64.const 5602881641763648953))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const 1)
+                   (i64.const -1) (i64.const -1))
+               (i64.const 1) (i64.const 1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const -1)
+                   (i64.const 3553816990259121806) (i64.const -2105235417856431622))
+               (i64.const -3553816990259121806) (i64.const 2105235417856431620))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 1861102705894987245) (i64.const 1)
+                   (i64.const 3713781778534059871) (i64.const 1))
+               (i64.const -1852679072639072626) (i64.const -1))
+(assert_return (invoke "i64.sub128"
+                   (i64.const 0) (i64.const -1)
+                   (i64.const 1) (i64.const 1832524486821761762))
+               (i64.const -1) (i64.const -1832524486821761764))
+
+;; assert overlong encodings for each instruction's binary encoding are accepted
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\0a"                  ;; type section, 10 bytes
+  "\01"                     ;; 1 count
+  "\60"                     ;; type0 = function
+  "\04\7e\7e\7e\7e"         ;;  4 params - all i64
+  "\02\7e\7e"               ;;  2 results - both i64
+
+  "\03\03"                  ;; function section, 3 bytes
+  "\02"                     ;; 2 count
+  "\00\00"                  ;; types of each function (0, 0)
+
+  "\07\1b"                  ;; export section 0x1b bytes
+  "\02"                     ;; 2 count
+  "\0ai64.add128\00\00"     ;; "i64.add128" which is function 0
+  "\0ai64.sub128\00\01"     ;; "i64.sub128" which is function 1
+
+  "\0a\1e"                  ;; code section + byte length (30 bytes = 0x1e)
+  "\02"                     ;; 2 count
+
+  "\0e"                     ;; byte length
+  "\00"                     ;; no locals
+  "\20\00"                  ;; local.get 0
+  "\20\01"                  ;; local.get 1
+  "\20\02"                  ;; local.get 2
+  "\20\03"                  ;; local.get 3
+  "\fc\93\80\00"            ;; i64.add128 (overlong)
+  "\0b"                     ;; end
+
+  "\0d"                     ;; byte length
+  "\00"                     ;; no locals
+  "\20\00"                  ;; local.get 0
+  "\20\01"                  ;; local.get 1
+  "\20\02"                  ;; local.get 2
+  "\20\03"                  ;; local.get 3
+  "\fc\94\00"               ;; i64.sub128 (overlong)
+  "\0b"                     ;; end
+)
+
+(assert_return (invoke "i64.add128"
+                  (i64.const 1) (i64.const 2)
+                  (i64.const 3) (i64.const 4))
+               (i64.const 4) (i64.const 6))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 2) (i64.const 5)
+                  (i64.const 1) (i64.const 2))
+               (i64.const 1) (i64.const 3))
+
+;; some invalid types for these instructions
+
+(assert_invalid
+  (module
+    (func (param i64 i64 i64 i64) (result i64)
+      local.get 0
+      local.get 1
+      local.get 2
+      local.get 3
+      i64.add128)
+  )
+  "type mismatch")
+(assert_invalid
+  (module
+    (func (param i64 i64 i64) (result i64 i64)
+      local.get 0
+      local.get 1
+      local.get 2
+      i64.add128)
+  )
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (func (param i64 i64 i64 i64) (result i64)
+      local.get 0
+      local.get 1
+      local.get 2
+      local.get 3
+      i64.sub128)
+  )
+  "type mismatch")
+(assert_invalid
+  (module
+    (func (param i64 i64 i64) (result i64 i64)
+      local.get 0
+      local.get 1
+      local.get 2
+      i64.sub128)
+  )
+  "type mismatch")

From 81d0c2573d100815bc7d70eeb4a0255b1e4d5ee6 Mon Sep 17 00:00:00 2001
From: stevenfontanella <stevenfont@chromium.org>
Date: Tue, 28 Apr 2026 16:27:23 +0000
Subject: [PATCH 2/4] PR updates

---
 src/wasm-delegations-fields.def |  6 +++---
 src/wasm-type.h                 | 18 ++++++++++++++----
 src/wasm/wasm-type.cpp          |  5 +++++
 src/wasm/wasm-validator.cpp     |  2 +-
 src/wasm/wasm.cpp               |  3 ++-
 5 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
index f8228f33203..f346bfde883 100644
--- a/src/wasm-delegations-fields.def
+++ b/src/wasm-delegations-fields.def
@@ -933,10 +933,10 @@ DELEGATE_FIELD_CASE_END(StructNotify)
 
 DELEGATE_FIELD_CASE_START(WideIntAddSub)
 DELEGATE_FIELD_INT(WideIntAddSub, op)
-DELEGATE_FIELD_CHILD(WideIntAddSub, leftLow)
-DELEGATE_FIELD_CHILD(WideIntAddSub, leftHigh)
-DELEGATE_FIELD_CHILD(WideIntAddSub, rightLow)
 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-type.h b/src/wasm-type.h
index 4033c6a36b6..b5ecd3ff66b 100644
--- a/src/wasm-type.h
+++ b/src/wasm-type.h
@@ -581,14 +581,18 @@ class Type {
   };
 
   Iterator begin() const { return Iterator{{this, 0}}; }
-  Iterator end() const { return Iterator{{this, size()}}; }
+  Iterator end() const {
+    return Iterator{{this, size()}};
+  }
   std::reverse_iterator<Iterator> rbegin() const {
     return std::make_reverse_iterator(end());
   }
   std::reverse_iterator<Iterator> rend() const {
     return std::make_reverse_iterator(begin());
   }
-  const Type& operator[](size_t i) const { return *Iterator{{this, i}}; }
+  const Type& operator[](size_t i) const {
+    return *Iterator{{this, i}};
+  }
 };
 
 Type Type::asWrittenGivenFeatures(FeatureSet feats) const {
@@ -645,6 +649,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
@@ -669,8 +675,12 @@ class RecGroup {
   };
 
   Iterator begin() const { return Iterator{{this, 0}}; }
-  Iterator end() const { return Iterator{{this, size()}}; }
-  HeapType operator[](size_t i) const { return *Iterator{{this, i}}; }
+  Iterator end() const {
+    return Iterator{{this, size()}};
+  }
+  HeapType operator[](size_t i) const {
+    return *Iterator{{this, i}};
+  }
 };
 
 struct Signature {
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
index 8826985ca19..a842068fa5f 100644
--- a/src/wasm/wasm-type.cpp
+++ b/src/wasm/wasm-type.cpp
@@ -2848,6 +2848,11 @@ HeapType getMutI16Array() {
   return i16Array;
 }
 
+Type getI64Pair() {
+  static Type i64Pair({Type::i64, Type::i64});
+  return i64Pair;
+}
+
 } // namespace wasm::HeapTypes
 
 namespace std {
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index 7ad1281ea31..9f9d6db8c2c 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -2455,7 +2455,7 @@ void FunctionValidator::visitWideIntAddSub(WideIntAddSub* curr) {
   for (auto* operand :
        {curr->leftLow, curr->leftHigh, curr->rightLow, curr->rightHigh}) {
     shouldBeEqualOrFirstIsUnreachable(operand->type,
-                                      Type(Type::BasicType::i64),
+                                      Type(Type::i64),
                                       curr,
                                       "wide binary child types must be i64");
   }
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index abfd1ddfd05..4ff165b8e8c 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -810,7 +810,8 @@ void WideIntAddSub::finalize() {
       rightHigh->type == Type::unreachable) {
     type = Type::unreachable;
   } else {
-    type = Type({Type::i64, Type::i64});
+    static Type i64Pair = HeapTypes::getI64Pair();
+    type = i64Pair;
   }
 }
 

From 4eea2fad91d3fb87eef12604111d5e7694c42f47 Mon Sep 17 00:00:00 2001
From: stevenfontanella <stevenfont@chromium.org>
Date: Tue, 28 Apr 2026 16:40:38 +0000
Subject: [PATCH 3/4] Fix spurious formatting change

---
 src/wasm-type.h | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/wasm-type.h b/src/wasm-type.h
index b5ecd3ff66b..767c005faaa 100644
--- a/src/wasm-type.h
+++ b/src/wasm-type.h
@@ -581,18 +581,14 @@ class Type {
   };
 
   Iterator begin() const { return Iterator{{this, 0}}; }
-  Iterator end() const {
-    return Iterator{{this, size()}};
-  }
+  Iterator end() const { return Iterator{{this, size()}}; }
   std::reverse_iterator<Iterator> rbegin() const {
     return std::make_reverse_iterator(end());
   }
   std::reverse_iterator<Iterator> rend() const {
     return std::make_reverse_iterator(begin());
   }
-  const Type& operator[](size_t i) const {
-    return *Iterator{{this, i}};
-  }
+  const Type& operator[](size_t i) const { return *Iterator{{this, i}}; }
 };
 
 Type Type::asWrittenGivenFeatures(FeatureSet feats) const {
@@ -675,12 +671,8 @@ class RecGroup {
   };
 
   Iterator begin() const { return Iterator{{this, 0}}; }
-  Iterator end() const {
-    return Iterator{{this, size()}};
-  }
-  HeapType operator[](size_t i) const {
-    return *Iterator{{this, i}};
-  }
+  Iterator end() const { return Iterator{{this, size()}}; }
+  HeapType operator[](size_t i) const { return *Iterator{{this, i}}; }
 };
 
 struct Signature {

From 80fe1b79f464db9aeb6fb45a1dfb55604d9211eb Mon Sep 17 00:00:00 2001
From: stevenfontanella <stevenfont@chromium.org>
Date: Tue, 28 Apr 2026 22:42:38 +0000
Subject: [PATCH 4/4] Small fix to interpreter logic

---
 src/wasm-interpreter.h | 46 ++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 14e8f8e5af4..8dd1bb4f4c6 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1806,34 +1806,32 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(leftHigh, curr->leftHigh);
     VISIT(rightLow, curr->rightLow);
     VISIT(rightHigh, curr->rightHigh);
-    if (curr->op == AddInt128 || curr->op == SubInt128) {
-      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;
+    uint64_t lowLHS = leftLow.getSingleValue().geti64();
+    uint64_t highLHS = leftHigh.getSingleValue().geti64();
+    uint64_t lowRHS = rightLow.getSingleValue().geti64();
+    uint64_t highRHS = rightHigh.getSingleValue().geti64();
 
-      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;
-        }
-      }
+    uint64_t lowResult = 0;
+    uint64_t highResult = 0;
 
-      Literals results;
-      results.push_back(Literal(lowResult));
-      results.push_back(Literal(highResult));
-      return results;
+    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;
+      }
     }
-    WASM_UNREACHABLE("invalid wide int binary op");
+
+    Literals results;
+    results.push_back(Literal(lowResult));
+    results.push_back(Literal(highResult));
+    return results;
   }
   Flow visitDrop(Drop* curr) {
     VISIT(value, curr->value)