[wasm] Int64Lowering of Int64Sub on ia32 and arm.

src/arm/simulator-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #if V8_TARGET_ARCH_ARM
 
@@ skipping 1315 matching lines @@
   uint32_t uleft = static_cast<uint32_t>(left);
   uint32_t uright = static_cast<uint32_t>(right);
   uint32_t urest  = 0xffffffffU - uleft;
 
   return (uright > urest) ||
          (carry && (((uright + 1) > urest) || (uright > (urest - 1))));
 }
 
 
 // Calculate C flag value for subtractions.
-bool Simulator::BorrowFrom(int32_t left, int32_t right) {
+bool Simulator::BorrowFrom(int32_t left, int32_t right, int32_t carry) {
   uint32_t uleft = static_cast<uint32_t>(left);
   uint32_t uright = static_cast<uint32_t>(right);
 
-  return (uright > uleft);
+  return (uright > uleft) ||
+         (carry && (((uright + 1) > uleft) || (uright > (uleft - 1))));

[jbramley, 2016/03/11 15:23:43]

This gets the wrong result if left == right.

Carry = 0:
- result = (left - right) - (carry ? 0 : 1) = 0xffffffff
- carry_out should be 0, but this method gives 1.

Carry = 1:
- result = (left - right) - (carry ? 0 : 1) = 0x00000000
- carry_out should be 1, but this method gives 0.

[ahaas, 2016/03/15 11:01:42]

Fixed. I use the negation of carry in the calculation now. Additionally it was
necessary to change the default value of carry to 1 instead of 0.

 }
 
 
 // Calculate V flag value for additions and subtractions.
 bool Simulator::OverflowFrom(int32_t alu_out,
                              int32_t left, int32_t right, bool addition) {
   bool overflow;
   if (addition) {
                // operands have the same sign
     overflow = ((left >= 0 && right >= 0) || (left < 0 && right < 0))
@@ skipping 1135 matching lines @@
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
           SetCFlag(CarryFrom(rn_val, shifter_operand, GetCarry()));
           SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
         }
         break;
       }
 
       case SBC: {
-        Format(instr, "sbc'cond's 'rd, 'rn, 'shift_rm");
-        Format(instr, "sbc'cond's 'rd, 'rn, 'imm");
+        //        Format(instr, "sbc'cond's 'rd, 'rn, 'shift_rm");
+        //        Format(instr, "sbc'cond's 'rd, 'rn, 'imm");
+        alu_out = (rn_val - shifter_operand) - (GetCarry() ? 0 : 1);
+        set_register(rd, alu_out);
+        if (instr->HasS()) {
+          SetNZFlags(alu_out);
+          SetCFlag(!BorrowFrom(rn_val, shifter_operand, GetCarry()));
+          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
+        }
         break;
       }
 
       case RSC: {
         Format(instr, "rsc'cond's 'rd, 'rn, 'shift_rm");
         Format(instr, "rsc'cond's 'rd, 'rn, 'imm");
         break;
       }
 
       case TST: {
@@ skipping 1759 matching lines @@
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM