diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index d8ebce98e31..282854757ea 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -150,6 +150,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
index ecb8b6218bc..8f872676a96 100644
--- a/scripts/test/shared.py
+++ b/scripts/test/shared.py
@@ -404,7 +404,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
index d3d3b99a702..ac2ab0a1330 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -3991,12 +3991,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
index e3abe63525d..96a1f41a424 100644
--- 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
index 6c722cbb03c..07820ed6eee 100644
--- 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
index 2aa1a06d549..b87cd3f9c16 100644
--- a/src/ir/child-typer.h
+++ b/src/ir/child-typer.h
@@ -712,6 +712,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
index 7d044a49947..99bf7c05333 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -579,6 +579,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 4 + 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
index ec96053a13d..44cc8031f45 100644
--- 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
index 08cf1cf4f8d..3e1213cd05b 100644
--- 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
index b0a910f3fa7..940144cba04 100644
--- 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
index e62d3d5869a..eac35a543c5 100644
--- 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
index c0d2804e29f..ffbcdfae233 100644
--- 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
index 0724b448674..ddf072caa2b 100644
--- 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
index c926c914720..4ffdb031dd4 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2045,6 +2045,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
index 1cd9a1b7885..749372ff107 100644
--- 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/support/CMakeLists.txt b/src/support/CMakeLists.txt
index d264979e7a8..3fc559ff36b 100644
--- a/src/support/CMakeLists.txt
+++ b/src/support/CMakeLists.txt
@@ -7,6 +7,7 @@ set(support_SOURCES
   debug.cpp
   dfa_minimization.cpp
   file.cpp
+  int128.cpp
   intervals.cpp
   istring.cpp
   json.cpp
diff --git a/src/support/int128.cpp b/src/support/int128.cpp
new file mode 100644
index 00000000000..b1e676b672d
--- /dev/null
+++ b/src/support/int128.cpp
@@ -0,0 +1,89 @@
+// Copyright 2024 WebAssembly Community Group participants
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "support/int128.h"
+
+namespace wasm {
+
+#ifdef __SIZEOF_INT128__
+
+Int128 mul_wide_s(uint64_t lhs, uint64_t rhs) {
+  __int128 result = static_cast<__int128>(static_cast<int64_t>(lhs)) *
+                    static_cast<__int128>(static_cast<int64_t>(rhs));
+  return {static_cast<uint64_t>(result >> 64), static_cast<uint64_t>(result)};
+}
+
+Int128 mul_wide_u(uint64_t lhs, uint64_t rhs) {
+  unsigned __int128 result =
+    static_cast<unsigned __int128>(lhs) * static_cast<unsigned __int128>(rhs);
+  return {static_cast<uint64_t>(result >> 64), static_cast<uint64_t>(result)};
+}
+
+#else
+
+Int128 mul_wide_s(uint64_t lhs, uint64_t rhs) {
+  return detail::mul_wide_s_fallback(lhs, rhs);
+}
+
+Int128 mul_wide_u(uint64_t lhs, uint64_t rhs) {
+  return detail::mul_wide_u_fallback(lhs, rhs);
+}
+
+#endif
+
+namespace detail {
+
+Int128 mul_wide_s_fallback(uint64_t lhs, uint64_t rhs) {
+  auto [high, low] = mul_wide_u_fallback(lhs, rhs);
+
+  if (static_cast<int64_t>(lhs) < 0) {
+    high -= rhs;
+  }
+  if (static_cast<int64_t>(rhs) < 0) {
+    high -= lhs;
+  }
+
+  return {high, low};
+}
+
+Int128 mul_wide_u_fallback(uint64_t lhs, uint64_t rhs) {
+  uint32_t lhsLow = lhs & 0xffffffff;
+  uint32_t lhsHigh = lhs >> 32;
+  uint32_t rhsLow = rhs & 0xffffffff;
+  uint32_t rhsHigh = rhs >> 32;
+
+  uint64_t mulLowLow = static_cast<uint64_t>(lhsLow) * rhsLow;
+  uint64_t mulLowHigh = static_cast<uint64_t>(lhsLow) * rhsHigh;
+  uint64_t mulHighLow = static_cast<uint64_t>(lhsHigh) * rhsLow;
+  uint64_t mulHighHigh = static_cast<uint64_t>(lhsHigh) * rhsHigh;
+
+  uint64_t cross = mulLowHigh + (mulLowLow >> 32);
+  uint64_t carry = cross >> 32;
+  cross = (cross & 0xffffffff) + mulHighLow;
+
+  // The lower 64 bits of the 128-bit result are formed by:
+  //   (low * low) + ((low * high) << 32) + ((high * low) << 32)
+  //
+  // The upper 64 bits of the 128-bit result are formed by:
+  //   (high * high) + the upper 32-bits of (low * high) + the upper 32-bits of
+  //   (high * low) + carries from the lower 64 bits
+  uint64_t lowResult = (cross << 32) | (mulLowLow & 0xffffffff);
+  uint64_t highResult = mulHighHigh + carry + (cross >> 32);
+
+  return {highResult, lowResult};
+}
+
+} // namespace detail
+
+} // namespace wasm
diff --git a/src/support/int128.h b/src/support/int128.h
new file mode 100644
index 00000000000..a63c2e85d54
--- /dev/null
+++ b/src/support/int128.h
@@ -0,0 +1,45 @@
+// Copyright 2024 WebAssembly Community Group participants
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef wasm_support_int128_h
+#define wasm_support_int128_h
+
+#include <cstdint>
+
+namespace wasm {
+
+struct Int128 {
+  uint64_t high;
+  uint64_t low;
+
+  bool operator==(const Int128& other) const {
+    return high == other.high && low == other.low;
+  }
+};
+
+// Computes the 128-bit product of two signed 64-bit integers.
+Int128 mul_wide_s(uint64_t lhs, uint64_t rhs);
+
+// Computes the 128-bit product of two unsigned 64-bit integers.
+Int128 mul_wide_u(uint64_t lhs, uint64_t rhs);
+
+namespace detail {
+// Fallback implementations exposed for testing.
+Int128 mul_wide_s_fallback(uint64_t lhs, uint64_t rhs);
+Int128 mul_wide_u_fallback(uint64_t lhs, uint64_t rhs);
+} // namespace detail
+
+} // namespace wasm
+
+#endif // wasm_support_i128_h
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 85458e97a3b..92bb588d53c 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1142,6 +1142,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
index cd9d0c34ddd..1c8894c4094 100644
--- 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
index f346bfde883..79ac534864f 100644
--- 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
index 92572b01198..8d14135ae54 100644
--- 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
index 8dd1bb4f4c6..67101d641e8 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -45,6 +45,7 @@
 #include "ir/runtime-table.h"
 #include "ir/table-utils.h"
 #include "support/bits.h"
+#include "support/int128.h"
 #include "support/safe_integer.h"
 #include "support/stdckdint.h"
 #include "support/string.h"
@@ -1833,6 +1834,29 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     results.push_back(Literal(highResult));
     return results;
   }
+  Flow visitWideIntMul(WideIntMul* curr) {
+    VISIT(left, curr->left);
+    VISIT(right, curr->right);
+    uint64_t lhs = left.getSingleValue().geti64();
+    uint64_t rhs = right.getSingleValue().geti64();
+
+    Int128 result;
+    switch (curr->op) {
+      case MulWideSInt64: {
+        result = mul_wide_s(lhs, rhs);
+        break;
+      }
+      case MulWideUInt64: {
+        result = mul_wide_u(lhs, rhs);
+        break;
+      }
+    }
+
+    Literals results;
+    results.push_back(Literal(result.low));
+    results.push_back(Literal(result.high));
+    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
index 9b87cba55e2..21ed4650202 100644
--- 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
index be7904bb674..6fe34edb08f 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -645,6 +645,11 @@ enum WideIntAddSubOp {
   SubInt128,
 };
 
+enum WideIntMulOp {
+  MulWideSInt64,
+  MulWideUInt64,
+};
+
 //
 // Expressions
 //
@@ -775,6 +780,7 @@ class Expression {
     StructWaitId,
     StructNotifyId,
     WideIntAddSubId,
+    WideIntMulId,
     NumExpressionIds
   };
   Id _id;
@@ -1320,6 +1326,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
index 368203ba5ff..61d505bd205 100644
--- 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
index be6148496c0..8e924414587 100644
--- 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
index 93521cb1e26..8cb99e9cccb 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2309,6 +2309,20 @@ void BinaryInstWriter::visitWideIntAddSub(WideIntAddSub* curr) {
   }
 }
 
+void BinaryInstWriter::visitWideIntMul(WideIntMul* curr) {
+  o << static_cast<int8_t>(BinaryConsts::MiscPrefix);
+  switch (curr->op) {
+    case MulWideSInt64: {
+      o << U32LEB(BinaryConsts::I64MulWideS);
+      break;
+    }
+    case MulWideUInt64: {
+      o << U32LEB(BinaryConsts::I64MulWideU);
+      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 9f9d6db8c2c..954f0676f55 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -509,6 +509,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitMemoryFill(MemoryFill* curr);
   void visitBinary(Binary* curr);
   void visitWideIntAddSub(WideIntAddSub* curr);
+  void visitWideIntMul(WideIntMul* curr);
   void visitUnary(Unary* curr);
   void visitSelect(Select* curr);
   void visitDrop(Drop* curr);
@@ -2461,6 +2462,20 @@ void FunctionValidator::visitWideIntAddSub(WideIntAddSub* curr) {
   }
 }
 
+void FunctionValidator::visitWideIntMul(WideIntMul* curr) {
+  shouldBeTrue(getModule()->features.hasWideArithmetic(),
+               curr,
+               "i64.mul_wide_s / i64.mul_wide_u require wide arithmetic "
+               "[--enable-wide-arithmetic]");
+
+  for (auto* operand : {curr->left, curr->right}) {
+    shouldBeEqualOrFirstIsUnreachable(operand->type,
+                                      Type(Type::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 c2feec54bf3..85c308ea645 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -815,6 +815,15 @@ void WideIntAddSub::finalize() {
   }
 }
 
+void WideIntMul::finalize() {
+  if (left->type == Type::unreachable || right->type == Type::unreachable) {
+    type = Type::unreachable;
+  } else {
+    static Type i64Pair = Types::getI64Pair();
+    type = i64Pair;
+  }
+}
+
 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 735669d3d27..08ac6e6e26e 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -1964,6 +1964,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       WASM_UNREACHABLE("wide arithmetic is not supported by wasm2js");
     }
 
+    Ref visitWideIntMul(WideIntMul* 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/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index 1c8e2de179f..254f7a38c9f 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -14,6 +14,7 @@ set(unittest_SOURCES
   dfa_minimization.cpp
   disjoint_sets.cpp
   graph.cpp
+  int128.cpp
   leaves.cpp
   glbs.cpp
   interpreter.cpp
diff --git a/test/gtest/int128.cpp b/test/gtest/int128.cpp
new file mode 100644
index 00000000000..e98d2d8082b
--- /dev/null
+++ b/test/gtest/int128.cpp
@@ -0,0 +1,95 @@
+// Copyright 2024 WebAssembly Community Group participants
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "support/int128.h"
+#include "gtest/gtest.h"
+#include <limits>
+
+using namespace wasm;
+
+class Int128MulWideSTest
+  : public ::testing::TestWithParam<Int128 (*)(uint64_t, uint64_t)> {};
+
+TEST_P(Int128MulWideSTest, Basic) {
+  auto mul_s = GetParam();
+
+  // Simple cases
+  EXPECT_EQ(mul_s(0, 0), (Int128{0, 0}));
+  EXPECT_EQ(mul_s(1, 1), (Int128{0, 1}));
+
+  // Mixed sign
+  EXPECT_EQ(mul_s(-1, 1),
+            (Int128{0xffffffffffffffffULL, 0xffffffffffffffffULL}));
+  EXPECT_EQ(mul_s(1, -1),
+            (Int128{0xffffffffffffffffULL, 0xffffffffffffffffULL}));
+
+  // Double negative
+  EXPECT_EQ(mul_s(-1, -1), (Int128{0, 1}));
+
+  int64_t maxInt = std::numeric_limits<int64_t>::max();
+  // Fits in the lower half because the signed bit now goes in the upper half.
+  EXPECT_EQ(mul_s(maxInt, 2), (Int128{0, 0xfffffffffffffffeULL}));
+  EXPECT_EQ(mul_s(maxInt, maxInt), (Int128{0x3fffffffffffffffULL, 1}));
+
+  // Min Ints (0x8000000000000000)
+  int64_t minInt = std::numeric_limits<int64_t>::min();
+  EXPECT_EQ(mul_s(minInt, 2), (Int128{0xffffffffffffffffULL, 0}));
+  EXPECT_EQ(mul_s(minInt, minInt), (Int128{0x4000000000000000ULL, 0}));
+}
+
+INSTANTIATE_TEST_SUITE_P(Int128,
+                         Int128MulWideSTest,
+                         ::testing::Values(mul_wide_s,
+                                           detail::mul_wide_s_fallback));
+
+class Int128MulWideUTest
+  : public ::testing::TestWithParam<Int128 (*)(uint64_t, uint64_t)> {};
+
+TEST_P(Int128MulWideUTest, Basic) {
+  auto mul_u = GetParam();
+
+  // Simple cases
+  EXPECT_EQ(mul_u(0, 0), (Int128{0, 0}));
+  EXPECT_EQ(mul_u(1, 0), (Int128{0, 0}));
+  EXPECT_EQ(mul_u(1, 1), (Int128{0, 1}));
+
+  // Max Uint (0xffffffffffffffff)
+  uint64_t maxUint = std::numeric_limits<uint64_t>::max();
+  EXPECT_EQ(mul_u(maxUint, 2), (Int128{1, 0xfffffffffffffffeULL}));
+  EXPECT_EQ(mul_u(maxUint, maxUint), (Int128{0xfffffffffffffffeULL, 1}));
+
+  // Max 32-bit uint (0xffffffff)
+  EXPECT_EQ(mul_u(0xffffffffULL, 0xffffffffULL),
+            (Int128{0, 0xfffffffe00000001ULL}));
+
+  // Exactly 2^32 (0x100000000) - Tests a 1 in the lowest bit of the high half
+  EXPECT_EQ(mul_u(0x100000000ULL, 0x100000000ULL), (Int128{1, 0}));
+
+  // Mixed boundaries
+  EXPECT_EQ(mul_u(0xffffffffULL, 0x100000000ULL),
+            (Int128{0, 0xffffffff00000000ULL}));
+
+  // Upper half filled, lower half empty
+  uint64_t highOnly = 0xffffffff00000000ULL;
+  EXPECT_EQ(mul_u(highOnly, 2), (Int128{1, 0xfffffffe00000000ULL}));
+
+  // Lower half filled, upper half empty
+  uint64_t lowOnly = 0x00000000ffffffffULL;
+  EXPECT_EQ(mul_u(lowOnly, lowOnly), (Int128{0, 0xfffffffe00000001ULL}));
+}
+
+INSTANTIATE_TEST_SUITE_P(Int128,
+                         Int128MulWideUTest,
+                         ::testing::Values(mul_wide_u,
+                                           detail::mul_wide_u_fallback));
diff --git a/test/spec/wide-arithmetic.wast b/test/spec/wide-arithmetic.wast
deleted file mode 100644
index 8c0cca7c368..00000000000
--- a/test/spec/wide-arithmetic.wast
+++ /dev/null
@@ -1,310 +0,0 @@
-;; 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")