Add sub

Author: stevenfontanella

scripts/gen-s-parser.py

@@ -147,6 +147,7 @@
     ("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)"),

src/interpreter/interpreter.cpp

@@ -218,14 +218,20 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   }
   Flow visitSelect(Select* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitWideIntAddSub(WideIntAddSub* curr) {
-    if (curr->op == AddInt128) {
+    if (curr->op == AddInt128 || curr->op == SubInt128) {
       uint64_t highRHS = pop().geti64();
       uint64_t lowRHS = pop().geti64();
       uint64_t highLHS = pop().geti64();
       uint64_t lowLHS = pop().geti64();
 
-      uint64_t lowRes = lowLHS + lowRHS;
-      uint64_t highRes = highLHS + highRHS + (lowRes < lowLHS);
+      uint64_t lowRes, highRes;
+      if (curr->op == AddInt128) {
+        lowRes = lowLHS + lowRHS;
+        highRes = highLHS + highRHS + (lowRes < lowLHS);
+      } else {
+        lowRes = lowLHS - lowRHS;
+        highRes = highLHS - highRHS - (lowLHS < lowRHS);
+      }
 
       push(Literal(lowRes));
       push(Literal(highRes));

src/passes/Print.cpp

@@ -2031,6 +2031,9 @@ struct PrintExpressionContents
       case AddInt128:
         o << "i64.add128";
         break;
+      case SubInt128:
+        o << "i64.sub128";
+        break;
       default:
         WASM_UNREACHABLE("invalid wide int binary op");
     }

src/wasm-binary.h

@@ -1139,6 +1139,7 @@ enum ASTNodes {
   // wide arithmetic opcodes
 
   I64Add128 = 0x13,
+  I64Sub128 = 0x14,
 
   // reference types opcodes
 

src/wasm-interpreter.h

@@ -1802,14 +1802,20 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(leftHigh, curr->leftHigh);
     VISIT(rightLow, curr->rightLow);
     VISIT(rightHigh, curr->rightHigh);
-    if (curr->op == AddInt128) {
+    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 lowRes = lowLHS + lowRHS;
-      uint64_t highRes = highLHS + highRHS + (lowRes < lowLHS);
+      uint64_t lowRes, highRes;
+      if (curr->op == AddInt128) {
+        lowRes = lowLHS + lowRHS;
+        highRes = highLHS + highRHS + (lowRes < lowLHS);
+      } else {
+        lowRes = lowLHS - lowRHS;
+        highRes = highLHS - highRHS - (lowLHS < lowRHS);
+      }
 
       Literals results;
       results.push_back(Literal(lowRes));

src/wasm.h

@@ -640,6 +640,7 @@ enum StringEqOp {
 
 enum WideIntAddSubOp {
   AddInt128,
+  SubInt128,
 };
 
 //

src/wasm/wasm-binary.cpp

@@ -4000,6 +4000,8 @@ Result<> WasmBinaryReader::readInst() {
           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()));

src/wasm/wasm-stack.cpp

@@ -2293,6 +2293,9 @@ void BinaryInstWriter::visitWideIntAddSub(WideIntAddSub* curr) {
     case AddInt128:
       o << U32LEB(BinaryConsts::I64Add128);
       break;
+    case SubInt128:
+      o << U32LEB(BinaryConsts::I64Sub128);
+      break;
     default:
       WASM_UNREACHABLE("invalid wide int binary op");
   }

test/spec/wide-arithmetic.wast

@@ -5,6 +5,12 @@
     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
@@ -164,3 +170,25 @@
       i64.add128)
   )
   "type mismatch")
+
+;; 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 1) (i64.const 0)
+                  (i64.const 1) (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 0xffffffffffffffff) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 0) (i64.const 1)
+                  (i64.const 1) (i64.const 0))
+               (i64.const 0xffffffffffffffff) (i64.const 0))
+(assert_return (invoke "i64.sub128"
+                  (i64.const 1) (i64.const 2)
+                  (i64.const 3) (i64.const 4))
+               (i64.const 0xfffffffffffffffe) (i64.const 0xfffffffffffffffd))