Optimize the multiplication of two 32-bit unsigned integers.

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 6084 matching lines @@
   Register out_hi = out_pair->At(1).reg();
 
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
   }
   switch (op_kind()) {
     case Token::kBIT_AND: {
       __ and_(out_lo, left_lo, Operand(right_lo));
       __ and_(out_hi, left_hi, Operand(right_hi));
+      break;
     }
-    break;
     case Token::kBIT_OR: {
       __ orr(out_lo, left_lo, Operand(right_lo));
       __ orr(out_hi, left_hi, Operand(right_hi));
+      break;
     }
-    break;
     case Token::kBIT_XOR: {
      __ eor(out_lo, left_lo, Operand(right_lo));
      __ eor(out_hi, left_hi, Operand(right_hi));
+     break;
     }
-    break;
     case Token::kADD:
     case Token::kSUB: {
       if (op_kind() == Token::kADD) {
         __ adds(out_lo, left_lo, Operand(right_lo));
         __ adcs(out_hi, left_hi, Operand(right_hi));
       } else {
         ASSERT(op_kind() == Token::kSUB);
         __ subs(out_lo, left_lo, Operand(right_lo));
         __ sbcs(out_hi, left_hi, Operand(right_hi));
       }
       if (can_overflow()) {
         // Deopt on overflow.
         __ b(deopt, VS);
       }
       break;
     }
+    case Token::kMUL: {
+      // The product of two signed 32-bit integers fits in a signed 64-bit
+      // result without causing overflow.
+      // We deopt on larger inputs.
+      if (TargetCPUFeatures::arm_version() == ARMv7) {
+        __ cmp(left_hi, Operand(left_lo, ASR, 31));
+        __ cmp(right_hi, Operand(right_lo, ASR, 31), EQ);
+        __ b(deopt, NE);
+        __ smull(out_lo, out_hi, left_lo, right_lo);
+      } else {
+        __ b(deopt);
+      }
+      break;
+    }
     default:
       UNREACHABLE();
-    break;
   }
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptIntOverflowCheck(compiler, deopt, out_lo, out_hi);
   }
 }
 
 
 LocationSummary* ShiftMintOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 2;
@@ skipping 222 matching lines @@
 
 
 void BinaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register out = locs()->out(0).reg();
   ASSERT(out != left);
   switch (op_kind()) {
     case Token::kBIT_AND:
       __ and_(out, left, Operand(right));
-    break;
+      break;
     case Token::kBIT_OR:
       __ orr(out, left, Operand(right));
-    break;
+      break;
     case Token::kBIT_XOR:
       __ eor(out, left, Operand(right));
-    break;
+      break;
     case Token::kADD:
       __ add(out, left, Operand(right));
-    break;
+      break;
     case Token::kSUB:
       __ sub(out, left, Operand(right));
-    break;
+      break;
+    case Token::kMUL:
+      __ mul(out, left, right);
+      break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* ShiftUint32OpInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 1;
@@ skipping 33 matching lines @@
       // Invalid shift value.
       __ b(deopt);
     } else if (shift_value > kShifterLimit) {
       // Result is 0.
       __ eor(out, out, Operand(out));
     } else {
       // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
       switch (op_kind()) {
         case Token::kSHR:
           __ Lsr(out, left, shift_value);
-        break;
+          break;
         case Token::kSHL:
           __ Lsl(out, left, shift_value);
-        break;
+          break;
         default:
           UNREACHABLE();
       }
     }
     return;
   }
 
   // Non constant shift value.
 
   Register shifter = locs()->in(1).reg();
 
   __ mov(temp, Operand(shifter));
   __ SmiUntag(temp);
   __ CompareImmediate(temp, 0);
   // If shift value is < 0, deoptimize.
   __ b(deopt, LT);
   __ CompareImmediate(temp, kShifterLimit);
   // > kShifterLimit, result is 0.
   __ eor(out, out, Operand(out), HI);
   // Do the shift.
   switch (op_kind()) {
     case Token::kSHR:
       __ Lsr(out, left, temp, LS);
-    break;
+      break;
     case Token::kSHL:
       __ Lsl(out, left, temp, LS);
-    break;
+      break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnaryUint32OpInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 387 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer);
   __ LoadImmediate(R5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM