Expands the use of Immediate and Operand wrappers.

runtime/vm/intermediate_language_arm.cc

Index: runtime/vm/intermediate_language_arm.cc
===================================================================
--- runtime/vm/intermediate_language_arm.cc	(revision 40623)
+++ runtime/vm/intermediate_language_arm.cc	(working copy)
@@ -184,7 +184,7 @@
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
-    __ Lsl(result, result, shift + kSmiTagSize);
+    __ Lsl(result, result, Operand(shift + kSmiTagSize));
   } else {
     __ sub(result, result, Operand(1));
     const int32_t val =
@@ -2860,12 +2860,12 @@
     ASSERT((0 < value) && (value < kCountLimit));
     if (shift_left->can_overflow()) {
       // Check for overflow (preserve left).
-      __ Lsl(IP, left, value);
+      __ Lsl(IP, left, Operand(value));
       __ cmp(left, Operand(IP, ASR, value));
       __ b(deopt, NE);  // Overflow.
     }
     // Shift for result now we know there is no overflow.
-    __ Lsl(result, left, value);
+    __ Lsl(result, left, Operand(value));
     return;
   }
 
@@ -3122,7 +3122,8 @@
         // sarl operation masks the count to 5 bits.
         const intptr_t kCountLimit = 0x1F;
         intptr_t value = Smi::Cast(constant).Value();
-        __ Asr(result, left, Utils::Minimum(value + kSmiTagSize, kCountLimit));
+        __ Asr(result, left,
+            Operand(Utils::Minimum(value + kSmiTagSize, kCountLimit)));
         __ SmiTag(result);
         break;
       }
@@ -3313,12 +3314,12 @@
   ASSERT((0 < value) && (value < kCountLimit));
   if (shift_left->can_overflow()) {
     // Check for overflow (preserve left).
-    __ Lsl(IP, left, value);
+    __ Lsl(IP, left, Operand(value));
     __ cmp(left, Operand(IP, ASR, value));
     __ b(deopt, NE);  // Overflow.
   }
   // Shift for result now we know there is no overflow.
-  __ Lsl(result, left, value);
+  __ Lsl(result, left, Operand(value));
 }
 
 
@@ -3456,7 +3457,7 @@
       case Token::kSHR: {
         // sarl operation masks the count to 5 bits.
         const intptr_t kCountLimit = 0x1F;
-        __ Asr(result, left, Utils::Minimum(value, kCountLimit));
+        __ Asr(result, left, Operand(Utils::Minimum(value, kCountLimit)));
         break;
       }
 
@@ -4123,18 +4124,18 @@
 
   // X lane.
   __ vmovrs(out, EvenSRegisterOf(dvalue0));
-  __ Lsr(out, out, 31);
+  __ Lsr(out, out, Operand(31));
   // Y lane.
   __ vmovrs(temp, OddSRegisterOf(dvalue0));
-  __ Lsr(temp, temp, 31);
+  __ Lsr(temp, temp, Operand(31));
   __ orr(out, out, Operand(temp, LSL, 1));
   // Z lane.
   __ vmovrs(temp, EvenSRegisterOf(dvalue1));
-  __ Lsr(temp, temp, 31);
+  __ Lsr(temp, temp, Operand(31));
   __ orr(out, out, Operand(temp, LSL, 2));
   // W lane.
   __ vmovrs(temp, OddSRegisterOf(dvalue1));
-  __ Lsr(temp, temp, 31);
+  __ Lsr(temp, temp, Operand(31));
   __ orr(out, out, Operand(temp, LSL, 3));
   // Tag.
   __ SmiTag(out);
@@ -4676,10 +4677,10 @@
 
     // Upper 32-bits of X lane.
     __ vmovrs(out, OddSRegisterOf(dvalue0));
-    __ Lsr(out, out, 31);
+    __ Lsr(out, out, Operand(31));
     // Upper 32-bits of Y lane.
     __ vmovrs(TMP, OddSRegisterOf(dvalue1));
-    __ Lsr(TMP, TMP, 31);
+    __ Lsr(TMP, TMP, Operand(31));
     __ orr(out, out, Operand(TMP, LSL, 1));
     // Tag.
     __ SmiTag(out);
@@ -6306,29 +6307,29 @@
     switch (op_kind()) {
       case Token::kSHR: {
         if (shift < 32) {
-          __ Lsl(out_lo, left_hi, 32 - shift);
+          __ Lsl(out_lo, left_hi, Operand(32 - shift));
           __ orr(out_lo, out_lo, Operand(left_lo, LSR, shift));
-          __ Asr(out_hi, left_hi, shift);
+          __ Asr(out_hi, left_hi, Operand(shift));
         } else {
           if (shift == 32) {
             __ mov(out_lo, Operand(left_hi));
           } else {
-            __ Asr(out_lo, left_hi, shift - 32);
+            __ Asr(out_lo, left_hi, Operand(shift - 32));
           }
-          __ Asr(out_hi, left_hi, 31);
+          __ Asr(out_hi, left_hi, Operand(31));
         }
         break;
       }
       case Token::kSHL: {
         if (shift < 32) {
-          __ Lsr(out_hi, left_lo, 32 - shift);
+          __ Lsr(out_hi, left_lo, Operand(32 - shift));
           __ orr(out_hi, out_hi, Operand(left_hi, LSL, shift));
-          __ Lsl(out_lo, left_lo, shift);
+          __ Lsl(out_lo, left_lo, Operand(shift));
         } else {
           if (shift == 32) {
             __ mov(out_hi, Operand(left_lo));
           } else {
-            __ Lsl(out_hi, left_lo, shift - 32);
+            __ Lsl(out_hi, left_lo, Operand(shift - 32));
           }
           __ mov(out_lo, Operand(0));
         }
@@ -6369,7 +6370,7 @@
         __ cmp(shift, Operand(32));
 
         __ mov(out_lo, Operand(out_hi), HI);
-        __ Asr(out_hi, out_hi, 31, HI);
+        __ Asr(out_hi, out_hi, Operand(31), HI);
         __ sub(shift, shift, Operand(32), HI);
 
         __ rsb(IP, shift, Operand(32));
@@ -6547,10 +6548,10 @@
       // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
       switch (op_kind()) {
         case Token::kSHR:
-          __ Lsr(out, left, shift_value);
+          __ Lsr(out, left, Operand(shift_value));
           break;
         case Token::kSHL:
-          __ Lsl(out, left, shift_value);
+          __ Lsl(out, left, Operand(shift_value));
           break;
         default:
           UNREACHABLE();
@@ -6560,7 +6561,6 @@
   }
 
   // Non constant shift value.
-
   Register shifter = locs()->in(1).reg();
 
   __ mov(temp, Operand(shifter));
@@ -6654,7 +6654,7 @@
         out,
         temp);
     if (from_representation() == kUnboxedInt32) {
-      __ Asr(temp, value, kBitsPerWord - 1);
+      __ Asr(temp, value, Operand(kBitsPerWord - 1));
     } else {
       ASSERT(from_representation() == kUnboxedUint32);
       __ eor(temp, temp, Operand(temp));