Adds support for integer division for ARM chips without the sdiv instruction.

runtime/vm/intrinsifier_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 "vm/globals.h"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 653 matching lines @@
 //   - left > 0 && left < right
 // R1: Tagged left (dividend).
 // R0: Tagged right (divisor).
 // Returns with result in R0, OR:
 //   R1: Untagged result (remainder).
 static void EmitRemainderOperation(Assembler* assembler) {
   Label modulo;
   const Register left = R1;
   const Register right = R0;
   const Register result = R1;
+  const Register tmp = R2;
   ASSERT(left == result);
 
   // Check for quick zero results.
   __ cmp(left, ShifterOperand(0));
   __ mov(R0, ShifterOperand(0), EQ);
   __ bx(LR, EQ);  // left is 0? Return 0.
   __ cmp(left, ShifterOperand(right));
   __ mov(R0, ShifterOperand(0), EQ);
   __ bx(LR, EQ);  // left == right? Return 0.
 
   // Check if result should be left.
   __ cmp(left, ShifterOperand(0));
   __ b(&modulo, LT);
   // left is positive.
   __ cmp(left, ShifterOperand(right));
   // left is less than right, result is left.
   __ mov(R0, ShifterOperand(left), LT);
   __ bx(LR, LT);
 
   __ Bind(&modulo);
   // result <- left - right * (left / right)
   __ SmiUntag(left);
   __ SmiUntag(right);
-  __ sdiv(TMP, left, right);  // TMP <- left / right
-  __ mls(result, right, TMP, left);  // result <- left - right * TMP
+
+  __ IntegerDivide(tmp, left, right, D1, D0);
+
+  __ mls(result, right, tmp, left);  // result <- left - right * TMP
   return;
 }
 
 
 // Implementation:
 //  res = left % right;
 //  if (res < 0) {
 //    if (right < 0) {
 //      res = res - right;
 //    } else {
 //      res = res + right;
 //    }
 //  }
 bool Intrinsifier::Integer_modulo(Assembler* assembler) {
   // Check to see if we have integer division
-  if (!CPUFeatures::integer_division_supported())
-    return false;
-
   Label fall_through, subtract;
   TestBothArgumentsSmis(assembler, &fall_through);
   // R1: Tagged left (dividend).
   // R0: Tagged right (divisor).
   // Check if modulo by zero -> exception thrown in main function.
   __ cmp(R0, ShifterOperand(0));
   __ b(&fall_through, EQ);
   EmitRemainderOperation(assembler);
   // Untagged right in R0. Untagged remainder result in R1.
 
   __ cmp(R1, ShifterOperand(0));
   __ mov(R0, ShifterOperand(R1, LSL, 1), GE);  // Tag and move result to R0.
   __ bx(LR, GE);
 
   // Result is negative, adjust it.
   __ cmp(R0, ShifterOperand(0));
   __ sub(R0, R1, ShifterOperand(R0), LT);
   __ add(R0, R1, ShifterOperand(R0), GE);
   __ SmiTag(R0);
   __ Ret();
 
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Integer_remainder(Assembler* assembler) {
   // Check to see if we have integer division
-  if (!CPUFeatures::integer_division_supported())
-    return false;
-
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   // R1: Tagged left (dividend).
   // R0: Tagged right (divisor).
   // Check if modulo by zero -> exception thrown in main function.
   __ cmp(R0, ShifterOperand(0));
   __ b(&fall_through, EQ);
   EmitRemainderOperation(assembler);
   // Untagged remainder result in R1.
   __ mov(R0, ShifterOperand(R1, LSL, 1));  // Tag result and return.
   __ Ret();
 
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Integer_truncDivide(Assembler* assembler) {
   // Check to see if we have integer division
-  if (!CPUFeatures::integer_division_supported())
-    return false;
-
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ cmp(R0, ShifterOperand(0));
   __ b(&fall_through, EQ);  // If b is 0, fall through.
 
   __ SmiUntag(R0);
   __ SmiUntag(R1);
-  __ sdiv(R0, R1, R0);
+
+  __ IntegerDivide(R0, R1, R0, D1, D0);
+
   // Check the corner case of dividing the 'MIN_SMI' with -1, in which case we
   // cannot tag the result.
   __ CompareImmediate(R0, 0x40000000);
   __ SmiTag(R0, NE);  // Not equal. Okay to tag and return.
   __ bx(LR, NE);  // Return.
   __ Bind(&fall_through);
   return false;
 }
 
 
@@ skipping 908 matching lines @@
   __ Bind(&ok);
   __ Ret();
 
   __ Bind(&fall_through);
   return false;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM