Fix carry out calculation in ARM simulator.

runtime/vm/simulator_arm.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
 
@@ skipping 1203 matching lines @@
   c_flag_ = val;
 }
 
 
 // Set the oVerflow flag.
 void Simulator::SetVFlag(bool val) {
   v_flag_ = val;
 }
 
 
-// Calculate C flag value for additions.
-bool Simulator::CarryFrom(int32_t left, int32_t right) {
-  uint32_t uleft = static_cast<uint32_t>(left);
-  uint32_t uright = static_cast<uint32_t>(right);
-  uint32_t urest  = 0xffffffffU - uleft;
-
-  return (uright > urest);
+// Calculate C flag value for additions (and subtractions with adjusted args).
+bool Simulator::CarryFrom(int32_t left, int32_t right, int32_t carry) {
+  uint64_t uleft = static_cast<uint32_t>(left);
+  uint64_t uright = static_cast<uint32_t>(right);
+  uint64_t ucarry = static_cast<uint32_t>(carry);
+  return ((uleft + uright + ucarry) >> 32) != 0;
 }
 
 
-// Calculate C flag value for subtractions.
-bool Simulator::BorrowFrom(int32_t left, int32_t right) {
-  uint32_t uleft = static_cast<uint32_t>(left);
-  uint32_t uright = static_cast<uint32_t>(right);
-
-  return (uright > uleft);
-}
-
-
-// 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))
-               // and operands and result have different sign
-               && ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
-  } else {
-               // operands have different signs
-    overflow = ((left < 0 && right >= 0) || (left >= 0 && right < 0))
-               // and first operand and result have different signs
-               && ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
-  }
-  return overflow;
+// Calculate V flag value for additions (and subtractions with adjusted args).
+bool Simulator::OverflowFrom(int32_t left, int32_t right, int32_t carry) {
+  int64_t result = static_cast<int64_t>(left) + right + carry;
+  return (result >> 31) != (result >> 32);
 }
 
 
 // Addressing Mode 1 - Data-processing operands:
 // Get the value based on the shifter_operand with register.
 int32_t Simulator::GetShiftRm(Instr* instr, bool* carry_out) {
   Shift shift = instr->ShiftField();
   int shift_amount = instr->ShiftAmountField();
   int32_t result = get_register(instr->RmField());
   if (instr->Bit(4) == 0) {
@@ skipping 769 matching lines @@
     Register rn = instr->RnField();
     int32_t rn_val = get_register(rn);
     int32_t shifter_operand = 0;
     bool shifter_carry_out = 0;
     if (instr->TypeField() == 0) {
       shifter_operand = GetShiftRm(instr, &shifter_carry_out);
     } else {
       ASSERT(instr->TypeField() == 1);
       shifter_operand = GetImm(instr, &shifter_carry_out);
     }
+    int32_t carry_in;
     int32_t alu_out;
 
     switch (instr->OpcodeField()) {
       case AND: {
         // Format(instr, "and'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "and'cond's 'rd, 'rn, 'imm");
         alu_out = rn_val & shifter_operand;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
@@ skipping 14 matching lines @@
         break;
       }
 
       case SUB: {
         // Format(instr, "sub'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "sub'cond's 'rd, 'rn, 'imm");
         alu_out = rn_val - shifter_operand;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(!BorrowFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
+          SetCFlag(CarryFrom(rn_val, ~shifter_operand, 1));
+          SetVFlag(OverflowFrom(rn_val, ~shifter_operand, 1));
         }
         break;
       }
 
       case RSB: {
         // Format(instr, "rsb'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "rsb'cond's 'rd, 'rn, 'imm");
         alu_out = shifter_operand - rn_val;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(!BorrowFrom(shifter_operand, rn_val));
-          SetVFlag(OverflowFrom(alu_out, shifter_operand, rn_val, false));
+          SetCFlag(CarryFrom(shifter_operand, ~rn_val, 1));
+          SetVFlag(OverflowFrom(shifter_operand, ~rn_val, 1));
         }
         break;
       }
 
       case ADD: {
         // Format(instr, "add'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "add'cond's 'rd, 'rn, 'imm");
         alu_out = rn_val + shifter_operand;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(CarryFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
+          SetCFlag(CarryFrom(rn_val, shifter_operand, 0));
+          SetVFlag(OverflowFrom(rn_val, shifter_operand, 0));
         }
         break;
       }
 
       case ADC: {
         // Format(instr, "adc'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "adc'cond's 'rd, 'rn, 'imm");
-        alu_out = rn_val + shifter_operand + (c_flag_ ? 1 : 0);
+        carry_in = c_flag_ ? 1 : 0;
+        alu_out = rn_val + shifter_operand + carry_in;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(CarryFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
+          SetCFlag(CarryFrom(rn_val, shifter_operand, carry_in));
+          SetVFlag(OverflowFrom(rn_val, shifter_operand, carry_in));
         }
         break;
       }
 
       case SBC: {
         // Format(instr, "sbc'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "sbc'cond's 'rd, 'rn, 'imm");
-        alu_out = rn_val - shifter_operand - (!c_flag_ ? 1 : 0);
+        carry_in = c_flag_ ? 1 : 0;
+        alu_out = rn_val + ~shifter_operand + carry_in;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(!BorrowFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
+          SetCFlag(CarryFrom(rn_val, ~shifter_operand, carry_in));
+          SetVFlag(OverflowFrom(rn_val, ~shifter_operand, carry_in));
         }
         break;
       }
 
       case RSC: {
         // Format(instr, "rsc'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "rsc'cond's 'rd, 'rn, 'imm");
-        alu_out = shifter_operand - rn_val - (!c_flag_ ? 1 : 0);
+        carry_in = c_flag_ ? 1 : 0;
+        alu_out = shifter_operand + ~rn_val + carry_in;
         set_register(rd, alu_out);
         if (instr->HasS()) {
           SetNZFlags(alu_out);
-          SetCFlag(!BorrowFrom(shifter_operand, rn_val));
-          SetVFlag(OverflowFrom(alu_out, shifter_operand, rn_val, false));
+          SetCFlag(CarryFrom(shifter_operand, ~rn_val, carry_in));
+          SetVFlag(OverflowFrom(shifter_operand, ~rn_val, carry_in));
         }
         break;
       }
 
       case TST: {
         if (instr->HasS()) {
           // Format(instr, "tst'cond 'rn, 'shift_rm");
           // Format(instr, "tst'cond 'rn, 'imm");
           alu_out = rn_val & shifter_operand;
           SetNZFlags(alu_out);
@@ skipping 16 matching lines @@
         }
         break;
       }
 
       case CMP: {
         if (instr->HasS()) {
           // Format(instr, "cmp'cond 'rn, 'shift_rm");
           // Format(instr, "cmp'cond 'rn, 'imm");
           alu_out = rn_val - shifter_operand;
           SetNZFlags(alu_out);
-          SetCFlag(!BorrowFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, false));
+          SetCFlag(CarryFrom(rn_val, ~shifter_operand, 1));
+          SetVFlag(OverflowFrom(rn_val, ~shifter_operand, 1));
         } else {
           UnimplementedInstruction(instr);
         }
         break;
       }
 
       case CMN: {
         if (instr->HasS()) {
           // Format(instr, "cmn'cond 'rn, 'shift_rm");
           // Format(instr, "cmn'cond 'rn, 'imm");
           alu_out = rn_val + shifter_operand;
           SetNZFlags(alu_out);
-          SetCFlag(CarryFrom(rn_val, shifter_operand));
-          SetVFlag(OverflowFrom(alu_out, rn_val, shifter_operand, true));
+          SetCFlag(CarryFrom(rn_val, shifter_operand, 0));
+          SetVFlag(OverflowFrom(rn_val, shifter_operand, 0));
         } else {
           UnimplementedInstruction(instr);
         }
         break;
       }
 
       case ORR: {
         // Format(instr, "orr'cond's 'rd, 'rn, 'shift_rm");
         // Format(instr, "orr'cond's 'rd, 'rn, 'imm");
         alu_out = rn_val | shifter_operand;
@@ skipping 1655 matching lines @@
   set_register(kExceptionObjectReg, bit_cast<int32_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM