Fix ARM intrinsic code for integer <<.

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 503 matching lines @@
 
 void Intrinsifier::Integer_bitXor(Assembler* assembler) {
   Integer_bitXorFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through;
-  __ Push(R6);
   TestBothArgumentsSmis(assembler, &fall_through);
   __ CompareImmediate(R0, Smi::RawValue(Smi::kBits));
   __ b(&fall_through, HI);
 
   __ SmiUntag(R0);
 
   // Check for overflow by shifting left and shifting back arithmetically.
   // If the result is different from the original, there was overflow.
   __ mov(IP, Operand(R1, LSL, R0));
   __ cmp(R1, Operand(IP, ASR, R0));
 
   // No overflow, result in R0.
   __ mov(R0, Operand(R1, LSL, R0), EQ);
   __ bx(LR, EQ);
 
   // Arguments are Smi but the shift produced an overflow to Mint.
   __ CompareImmediate(R1, 0);
   __ b(&fall_through, LT);
   __ SmiUntag(R1);
 
   // Pull off high bits that will be shifted off of R1 by making a mask
   // ((1 << R0) - 1), shifting it to the left, masking R1, then shifting back.
   // high bits = (((1 << R0) - 1) << (32 - R0)) & R1) >> (32 - R0)
   // lo bits = R1 << R0
   __ LoadImmediate(NOTFP, 1);
   __ mov(NOTFP, Operand(NOTFP, LSL, R0));  // NOTFP <- 1 << R0
   __ sub(NOTFP, NOTFP, Operand(1));  // NOTFP <- NOTFP - 1
-  __ rsb(R6, R0, Operand(32));  // R6 <- 32 - R0
-  __ mov(NOTFP, Operand(NOTFP, LSL, R6));  // NOTFP <- NOTFP << R6
+  __ rsb(R3, R0, Operand(32));  // R3 <- 32 - R0
+  __ mov(NOTFP, Operand(NOTFP, LSL, R3));  // NOTFP <- NOTFP << R3
   __ and_(NOTFP, R1, Operand(NOTFP));  // NOTFP <- NOTFP & R1
-  __ mov(NOTFP, Operand(NOTFP, LSR, R6));  // NOTFP <- NOTFP >> R6
+  __ mov(NOTFP, Operand(NOTFP, LSR, R3));  // NOTFP <- NOTFP >> R3
   // Now NOTFP has the bits that fall off of R1 on a left shift.
   __ mov(R1, Operand(R1, LSL, R0));  // R1 gets the low bits.
 
   const Class& mint_class = Class::Handle(
       Isolate::Current()->object_store()->mint_class());
   __ TryAllocate(mint_class, &fall_through, R0, R2);
 
 
   __ str(R1, FieldAddress(R0, Mint::value_offset()));
   __ str(NOTFP, FieldAddress(R0, Mint::value_offset() + kWordSize));
-  __ Pop(R6);
   __ Ret();
   __ Bind(&fall_through);
-  ASSERT(CODE_REG == R6);
-  __ Pop(R6);
 }
 
 
 static void Get64SmiOrMint(Assembler* assembler,
                            Register res_hi,
                            Register res_lo,
                            Register reg,
                            Label* not_smi_or_mint) {
   Label not_smi, done;
   __ tst(reg, Operand(kSmiTagMask));
@@ skipping 1551 matching lines @@
   __ ldr(R0, Address(R0, TimelineStream::enabled_offset()));
   __ cmp(R0, Operand(0));
   __ LoadObject(R0, Bool::True(), NE);
   __ LoadObject(R0, Bool::False(), EQ);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM