Rename ShifterOperand to Operand on ARM.

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 73 matching lines @@
 // that will be overwritten by the patch instructions: a branch macro sequence.
 void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->in(0).reg();
   ASSERT(result == R0);
 #if defined(DEBUG)
   Label stack_ok;
   __ Comment("Stack Check");
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
-  __ sub(R2, SP, ShifterOperand(FP));
+  __ sub(R2, SP, Operand(FP));
   __ CompareImmediate(R2, fp_sp_dist);
   __ b(&stack_ok, EQ);
   __ bkpt(0);
   __ Bind(&stack_ok);
 #endif
   __ LeaveDartFrame();
   __ Ret();
 }
 
 
@@ skipping 31 matching lines @@
 
 
 void IfThenElseInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->out(0).reg();
 
   Location left = locs()->in(0);
   Location right = locs()->in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   // Clear out register.
-  __ eor(result, result, ShifterOperand(result));
+  __ eor(result, result, Operand(result));
 
   // Emit comparison code. This must not overwrite the result register.
   BranchLabels labels = { NULL, NULL, NULL };
   Condition true_condition = comparison()->EmitComparisonCode(compiler, labels);
 
   const bool is_power_of_two_kind = IsPowerOfTwoKind(if_true_, if_false_);
 
   intptr_t true_value = if_true_;
   intptr_t false_value = if_false_;
 
   if (is_power_of_two_kind) {
     if (true_value == 0) {
       // We need to have zero in result on true_condition.
       true_condition = NegateCondition(true_condition);
     }
   } else {
     if (true_value == 0) {
       // Swap values so that false_value is zero.
       intptr_t temp = true_value;
       true_value = false_value;
       false_value = temp;
     } else {
       true_condition = NegateCondition(true_condition);
     }
   }
 
-  __ mov(result, ShifterOperand(1), true_condition);
+  __ mov(result, Operand(1), true_condition);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ Lsl(result, result, shift + kSmiTagSize);
   } else {
-    __ sub(result, result, ShifterOperand(1));
+    __ sub(result, result, Operand(1));
     const int32_t val =
         Smi::RawValue(true_value) - Smi::RawValue(false_value);
     __ AndImmediate(result, result, val);
     if (false_value != 0) {
       __ AddImmediate(result, Smi::RawValue(false_value));
     }
   }
 }
 
 
@@ skipping 242 matching lines @@
   return NULL;
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   Label done;
   if (value_is_smi == NULL) {
-    __ mov(value_cid_reg, ShifterOperand(kSmiCid));
+    __ mov(value_cid_reg, Operand(kSmiCid));
   }
-  __ tst(value_reg, ShifterOperand(kSmiTagMask));
+  __ tst(value_reg, Operand(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ b(&done, EQ);
   } else {
     __ b(value_is_smi, EQ);
   }
   __ LoadClassId(value_cid_reg, value_reg);
   __ Bind(&done);
 }
 
 
@@ skipping 43 matching lines @@
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToSmiCondition(kind);
 
   if (left.IsConstant()) {
     __ CompareObject(right.reg(), left.constant());
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
     __ CompareObject(left.reg(), right.constant());
   } else {
-    __ cmp(left.reg(), ShifterOperand(right.reg()));
+    __ cmp(left.reg(), Operand(right.reg()));
   }
   return true_condition;
 }
 
 
 static Condition TokenKindToMintCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQ;
     case Token::kNE: return NE;
     case Token::kLT: return LT;
@@ skipping 12 matching lines @@
                                            Token::Kind kind) {
   ASSERT(Token::IsEqualityOperator(kind));
   PairLocation* left_pair = locs->in(0).AsPairLocation();
   Register left1 = left_pair->At(0).reg();
   Register left2 = left_pair->At(1).reg();
   PairLocation* right_pair = locs->in(1).AsPairLocation();
   Register right1 = right_pair->At(0).reg();
   Register right2 = right_pair->At(1).reg();
 
   // Compare lower.
-  __ cmp(left1, ShifterOperand(right1));
+  __ cmp(left1, Operand(right1));
   // Compare upper if lower is equal.
-  __ cmp(left2, ShifterOperand(right2), EQ);
+  __ cmp(left2, Operand(right2), EQ);
   return TokenKindToMintCondition(kind);
 }
 
 
 static Condition EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
                                              LocationSummary* locs,
                                              Token::Kind kind) {
   PairLocation* left_pair = locs->in(0).AsPairLocation();
   Register left1 = left_pair->At(0).reg();
   Register left2 = left_pair->At(1).reg();
@@ skipping 18 matching lines @@
       hi_false_cond = LT;
       lo_false_cond = (kind == Token::kGT) ? LS : CC;
       break;
     default:
       UNREACHABLE();
       hi_true_cond = hi_false_cond = lo_false_cond = VS;
   }
 
   Label is_true, is_false, done;
   // Compare upper halves first.
-  __ cmp(left2, ShifterOperand(right2));
+  __ cmp(left2, Operand(right2));
   __ LoadImmediate(out, 0, hi_false_cond);
   __ LoadImmediate(out, 1, hi_true_cond);
   // If higher words aren't equal, skip comparing lower words.
   __ b(&done, NE);
 
-  __ cmp(left1, ShifterOperand(right1));
+  __ cmp(left1, Operand(right1));
   __ LoadImmediate(out, 1);
   __ LoadImmediate(out, 0, lo_false_cond);
   __ Bind(&done);
 
   return NegateCondition(lo_false_cond);
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
@@ skipping 94 matching lines @@
 Condition TestSmiInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                            BranchLabels labels) {
   const Register left = locs()->in(0).reg();
   Location right = locs()->in(1);
   if (right.IsConstant()) {
     ASSERT(right.constant().IsSmi());
     const int32_t imm =
         reinterpret_cast<int32_t>(right.constant().raw());
     __ TestImmediate(left, imm);
   } else {
-    __ tst(left, ShifterOperand(right.reg()));
+    __ tst(left, Operand(right.reg()));
   }
   Condition true_condition = (kind() == Token::kNE) ? NE : EQ;
   return true_condition;
 }
 
 
 void TestSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Never emitted outside of the BranchInstr.
   UNREACHABLE();
 }
@@ skipping 26 matching lines @@
   const Register val_reg = locs()->in(0).reg();
   const Register cid_reg = locs()->temp(0).reg();
 
   Label* deopt = CanDeoptimize() ?
       compiler->AddDeoptStub(deopt_id(), ICData::kDeoptTestCids) : NULL;
 
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
-  __ tst(val_reg, ShifterOperand(kSmiTagMask));
+  __ tst(val_reg, Operand(kSmiTagMask));
   __ b(result ? labels.true_label : labels.false_label, EQ);
   __ LoadClassId(cid_reg, val_reg);
 
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
     ASSERT(test_cid != kSmiCid);
     result = data[i + 1] == true_result;
     __ CompareImmediate(cid_reg, test_cid);
     __ b(result ? labels.true_label : labels.false_label, EQ);
   }
@@ skipping 223 matching lines @@
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(cid_ == kOneByteStringCid);
   const Register str = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ ldr(result, FieldAddress(str, String::length_offset()));
-  __ cmp(result, ShifterOperand(Smi::RawValue(1)));
+  __ cmp(result, Operand(Smi::RawValue(1)));
   __ LoadImmediate(result, -1, NE);
   __ ldrb(result, FieldAddress(str, OneByteString::data_offset()), EQ);
   __ SmiTag(result);
 }
 
 
 LocationSummary* StringInterpolateInstr::MakeLocationSummary(Isolate* isolate,
                                                              bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 44 matching lines @@
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register object = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   Label load, done;
-  __ tst(object, ShifterOperand(kSmiTagMask));
+  __ tst(object, Operand(kSmiTagMask));
   __ b(&load, NE);
   __ LoadImmediate(result, Smi::RawValue(kSmiCid));
   __ b(&done);
   __ Bind(&load);
   __ LoadClassId(result, object);
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
@@ skipping 162 matching lines @@
   int32_t offset =
       is_external ? 0 : (Instance::DataOffsetFor(cid) - kHeapObjectTag);
   const OperandSize size = Address::OperandSizeFor(cid);
   ASSERT(array != IP);
   ASSERT(index != IP);
   const Register base = is_load ? IP : index;
   if ((offset != 0) ||
       (size == kSWord) || (size == kDWord) || (size == kRegList)) {
     if (shift < 0) {
       ASSERT(shift == -1);
-      assembler->add(base, array, ShifterOperand(index, ASR, 1));
+      assembler->add(base, array, Operand(index, ASR, 1));
     } else {
-      assembler->add(base, array, ShifterOperand(index, LSL, shift));
+      assembler->add(base, array, Operand(index, LSL, shift));
     }
   } else {
     if (shift < 0) {
       ASSERT(shift == -1);
       return Address(array, index, ASR, 1);
     } else {
       return Address(array, index, LSL, shift);
     }
   }
   int32_t offset_mask = 0;
@@ skipping 61 matching lines @@
       case kTypedDataInt32ArrayCid:
         // Load low word.
         __ ldr(result1, element_address);
         // Sign extend into high word.
         __ SignFill(result2, result1);
         break;
       case kTypedDataUint32ArrayCid:
         // Load low word.
         __ ldr(result1, element_address);
         // Zero high word.
-        __ eor(result2, result2, ShifterOperand(result2));
+        __ eor(result2, result2, Operand(result2));
         break;
       default:
         UNREACHABLE();
         break;
     }
     return;
   }
 
   ASSERT(representation() == kTagged);
 
@@ skipping 197 matching lines @@
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
         __ LoadImmediate(IP, static_cast<int8_t>(value));
         __ strb(IP, element_address);
       } else {
         const Register value = locs()->in(2).reg();
         Label store_value;
         __ SmiUntag(value);
-        __ cmp(value, ShifterOperand(0xFF));
+        __ cmp(value, Operand(0xFF));
         // Clamp to 0x00 or 0xFF respectively.
         __ b(&store_value, LS);
-        __ mov(value, ShifterOperand(0x00), LE);
-        __ mov(value, ShifterOperand(0xFF), GT);
+        __ mov(value, Operand(0x00), LE);
+        __ mov(value, Operand(0xFF), GT);
         __ Bind(&store_value);
         __ strb(value, element_address);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       const Register value = locs()->in(2).reg();
       __ SmiUntag(value);
       __ strh(value, element_address);
@@ skipping 110 matching lines @@
     FieldAddress field_length_operand(
         field_reg, Field::guarded_list_length_offset());
 
     ASSERT(value_cid_reg != kNoRegister);
     ASSERT((value_cid_reg != value_reg) && (field_reg != value_cid_reg));
 
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
       Label skip_length_check;
       __ ldr(IP, field_cid_operand);
-      __ cmp(value_cid_reg, ShifterOperand(IP));
+      __ cmp(value_cid_reg, Operand(IP));
       __ b(&skip_length_check, NE);
       if (field_has_length) {
         ASSERT(temp_reg != kNoRegister);
         // Field guard may have remembered list length, check it.
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           __ ldr(temp_reg,
                  FieldAddress(value_reg, Array::length_offset()));
           __ CompareImmediate(temp_reg, Smi::RawValue(field_length));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           __ ldr(temp_reg,
@@ skipping 18 matching lines @@
           __ b(&no_fixed_length, EQ);
           // Check for typed data array.
           __ CompareImmediate(value_cid_reg, kTypedDataInt32x4ArrayCid);
           __ b(&no_fixed_length, GT);
           __ CompareImmediate(value_cid_reg, kTypedDataInt8ArrayCid);
           // Could still be a regular array.
           __ b(&check_array, LT);
           __ ldr(temp_reg,
                  FieldAddress(value_reg, TypedData::length_offset()));
           __ ldr(IP, field_length_operand);
-          __ cmp(temp_reg, ShifterOperand(IP));
+          __ cmp(temp_reg, Operand(IP));
           __ b(&length_compared);
           // Check for regular array.
           __ Bind(&check_array);
           __ CompareImmediate(value_cid_reg, kImmutableArrayCid);
           __ b(&no_fixed_length, GT);
           __ CompareImmediate(value_cid_reg, kArrayCid);
           __ b(&no_fixed_length, LT);
           __ ldr(temp_reg,
                  FieldAddress(value_reg, Array::length_offset()));
           __ ldr(IP, field_length_operand);
-          __ cmp(temp_reg, ShifterOperand(IP));
+          __ cmp(temp_reg, Operand(IP));
           __ b(&length_compared);
           __ Bind(&no_fixed_length);
           __ b(fail);
           __ Bind(&length_compared);
           // Following branch cannot not occur, fall through.
         }
         __ b(fail, NE);
       }
       __ Bind(&skip_length_check);
       __ ldr(IP, field_nullability_operand);
-      __ cmp(value_cid_reg, ShifterOperand(IP));
+      __ cmp(value_cid_reg, Operand(IP));
     } else if (value_cid == kNullCid) {
       __ ldr(value_cid_reg, field_nullability_operand);
       __ CompareImmediate(value_cid_reg, value_cid);
     } else {
       Label skip_length_check;
       __ ldr(value_cid_reg, field_cid_operand);
       __ CompareImmediate(value_cid_reg, value_cid);
       __ b(&skip_length_check, NE);
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
@@ skipping 101 matching lines @@
     }
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(deopt != NULL);
     // Field guard class has been initialized and is known.
     if (field_reg != kNoRegister) {
       __ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
     }
     if (value_cid == kDynamicCid) {
       // Field's guarded class id is fixed by value's class id is not known.
-      __ tst(value_reg, ShifterOperand(kSmiTagMask));
+      __ tst(value_reg, Operand(kSmiTagMask));
 
       if (field_cid != kSmiCid) {
         __ b(fail, EQ);
         __ LoadClassId(value_cid_reg, value_reg);
         __ CompareImmediate(value_cid_reg, field_cid);
       }
 
       if (field_has_length) {
         __ b(fail, NE);
         // Classes are same, perform guarded list length check.
         ASSERT(field_reg != kNoRegister);
         ASSERT(value_cid_reg != kNoRegister);
         FieldAddress field_length_operand(
             field_reg, Field::guarded_list_length_offset());
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ ldr(value_cid_reg,
                  FieldAddress(value_reg, Array::length_offset()));
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ ldr(value_cid_reg,
                  FieldAddress(value_reg, TypedData::length_offset()));
         }
         __ ldr(IP, field_length_operand);
-        __ cmp(value_cid_reg, ShifterOperand(IP));
+        __ cmp(value_cid_reg, Operand(IP));
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ b(&ok, EQ);
         __ CompareImmediate(value_reg,
                             reinterpret_cast<intptr_t>(Object::null()));
       }
       __ b(fail, NE);
     } else {
       // Both value's and field's class id is known.
@@ skipping 164 matching lines @@
     Label store_float32x4;
     Label store_float64x2;
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()));
 
     __ ldr(temp2, FieldAddress(temp, Field::is_nullable_offset()));
     __ CompareImmediate(temp2, kNullCid);
     __ b(&store_pointer, EQ);
 
     __ ldrb(temp2, FieldAddress(temp, Field::kind_bits_offset()));
-    __ tst(temp2, ShifterOperand(1 << Field::kUnboxingCandidateBit));
+    __ tst(temp2, Operand(1 << Field::kUnboxingCandidateBit));
     __ b(&store_pointer, EQ);
 
     __ ldr(temp2, FieldAddress(temp, Field::guarded_cid_offset()));
     __ CompareImmediate(temp2, kDoubleCid);
     __ b(&store_double, EQ);
 
     __ ldr(temp2, FieldAddress(temp, Field::guarded_cid_offset()));
     __ CompareImmediate(temp2, kFloat32x4Cid);
     __ b(&store_float32x4, EQ);
 
@@ skipping 219 matching lines @@
   __ LoadImmediate(R6, heap->TopAddress());
   __ ldr(R0, Address(R6, 0));  // Potential new object start.
   __ AddImmediate(R7, R0, kArraySize);  // Potential next object start.
   __ b(slow_path, VS);
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
   // R7: potential next object start.
   __ LoadImmediate(R3, heap->EndAddress());
   __ ldr(R3, Address(R3, 0));
-  __ cmp(R7, ShifterOperand(R3));
+  __ cmp(R7, Operand(R3));
   __ b(slow_path, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ str(R7, Address(R6, 0));
-  __ add(R0, R0, ShifterOperand(kHeapObjectTag));
+  __ add(R0, R0, Operand(kHeapObjectTag));
   __ LoadImmediate(R8, heap->TopAddress());
   __ UpdateAllocationStatsWithSize(kArrayCid, R8, R4);
 
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   {
     uword tags = 0;
     tags = RawObject::ClassIdTag::update(kArrayCid, tags);
     tags = RawObject::SizeTag::update(kArraySize, tags);
@@ skipping 17 matching lines @@
   // R0: new object start as a tagged pointer.
   // R7: new object end address.
   // R8: iterator which initially points to the start of the variable
   // data area to be initialized.
   // R3: null
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
   __ AddImmediate(R8, R0, sizeof(RawArray) - kHeapObjectTag);
 
   Label init_loop;
   __ Bind(&init_loop);
-  __ cmp(R8, ShifterOperand(R7));
+  __ cmp(R8, Operand(R7));
   __ str(R3, Address(R8, 0), CC);
   __ AddImmediate(R8, kWordSize, CC);
   __ b(&init_loop, CC);
   __ b(done);
 }
 
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register kLengthReg = R2;
   const Register kElemTypeReg = R1;
@@ skipping 78 matching lines @@
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
-    __ mov(locs->out(0).reg(), ShifterOperand(R0));
+    __ mov(locs->out(0).reg(), Operand(R0));
     compiler->RestoreLiveRegisters(locs);
 
     __ b(exit_label());
   }
 
  private:
   Instruction* instruction_;
 };
 
 
@@ skipping 11 matching lines @@
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
-    __ mov(locs->out(0).reg(), ShifterOperand(R0));
+    __ mov(locs->out(0).reg(), Operand(R0));
     compiler->RestoreLiveRegisters(locs);
 
     __ b(exit_label());
   }
 
  private:
   Instruction* instruction_;
 };
 
 
@@ skipping 200 matching lines @@
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
     __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
-    __ cmp(instantiator_reg, ShifterOperand(IP));
+    __ cmp(instantiator_reg, Operand(IP));
     __ b(&type_arguments_instantiated, EQ);
   }
 
   __ LoadObject(R2, type_arguments());
   __ ldr(R2, FieldAddress(R2, TypeArguments::instantiations_offset()));
   __ AddImmediate(R2, Array::data_offset() - kHeapObjectTag);
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, found, slow_case;
   __ Bind(&loop);
   __ ldr(R1, Address(R2, 0 * kWordSize));  // Cached instantiator.
-  __ cmp(R1, ShifterOperand(R0));
+  __ cmp(R1, Operand(R0));
   __ b(&found, EQ);
   __ AddImmediate(R2, 2 * kWordSize);
   __ CompareImmediate(R1, Smi::RawValue(StubCode::kNoInstantiator));
   __ b(&loop, NE);
   __ b(&slow_case);
   __ Bind(&found);
   __ ldr(R0, Address(R2, 1 * kWordSize));  // Cached instantiated args.
   __ b(&type_arguments_instantiated);
 
   __ Bind(&slow_case);
@@ skipping 167 matching lines @@
   Label osr_entry_label_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   __ LoadImmediate(IP, Isolate::Current()->stack_limit_address());
   __ ldr(IP, Address(IP));
-  __ cmp(SP, ShifterOperand(IP));
+  __ cmp(SP, Operand(IP));
   __ b(slow_path->entry_label(), LS);
   if (compiler->CanOSRFunction() && in_loop()) {
     const Register temp = locs()->temp(0).reg();
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function());
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
     __ ldr(temp, FieldAddress(temp, Function::usage_counter_offset()));
@@ skipping 21 matching lines @@
     ASSERT(constant.IsSmi());
     // Immediate shift operation takes 5 bits for the count.
     const intptr_t kCountLimit = 0x1F;
     const intptr_t value = Smi::Cast(constant).Value();
     if (value == 0) {
       __ MoveRegister(result, left);
     } else if ((value < 0) || (value >= kCountLimit)) {
       // This condition may not be known earlier in some cases because
       // of constant propagation, inlining, etc.
       if ((value >= kCountLimit) && is_truncating) {
-        __ mov(result, ShifterOperand(0));
+        __ mov(result, Operand(0));
       } else {
         // Result is Mint or exception.
         __ b(deopt);
       }
     } else {
       if (!is_truncating) {
         // Check for overflow (preserve left).
         __ Lsl(IP, left, value);
-        __ cmp(left, ShifterOperand(IP, ASR, 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);
     }
     return;
   }
 
   // Right (locs.in(1)) is not constant.
   const Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
   if (shift_left->left()->BindsToConstant() && !is_truncating) {
     // TODO(srdjan): Implement code below for is_truncating().
     // If left is constant, we know the maximal allowed size for right.
     const Object& obj = shift_left->left()->BoundConstant();
     if (obj.IsSmi()) {
       const intptr_t left_int = Smi::Cast(obj).Value();
       if (left_int == 0) {
-        __ cmp(right, ShifterOperand(0));
+        __ cmp(right, Operand(0));
         __ b(deopt, MI);
-        __ mov(result, ShifterOperand(0));
+        __ mov(result, Operand(0));
         return;
       }
       const intptr_t max_right = kSmiBits - Utils::HighestBit(left_int);
       const bool right_needs_check =
           (right_range == NULL) ||
           !right_range->IsWithin(0, max_right - 1);
       if (right_needs_check) {
-        __ cmp(right,
-               ShifterOperand(reinterpret_cast<int32_t>(Smi::New(max_right))));
+        __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(max_right))));
         __ b(deopt, CS);
       }
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
       __ Lsl(result, left, IP);
     }
     return;
   }
 
   const bool right_needs_check =
       (right_range == NULL) || !right_range->IsWithin(0, (Smi::kBits - 1));
   if (is_truncating) {
     if (right_needs_check) {
       const bool right_may_be_negative =
           (right_range == NULL) ||
           !right_range->IsWithin(0, RangeBoundary::kPlusInfinity);
       if (right_may_be_negative) {
         ASSERT(shift_left->CanDeoptimize());
-        __ cmp(right, ShifterOperand(0));
+        __ cmp(right, Operand(0));
         __ b(deopt, MI);
       }
 
-      __ cmp(right,
-             ShifterOperand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
-      __ mov(result, ShifterOperand(0), CS);
+      __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
+      __ mov(result, Operand(0), CS);
       __ Asr(IP, right, kSmiTagSize, CC);  // SmiUntag right into IP if CC.
       __ Lsl(result, left, IP, CC);
     } else {
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
       __ Lsl(result, left, IP);
     }
   } else {
     if (right_needs_check) {
       ASSERT(shift_left->CanDeoptimize());
-      __ cmp(right,
-             ShifterOperand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
+      __ cmp(right, Operand(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
       __ b(deopt, CS);
     }
     // Left is not a constant.
     // Check if count too large for handling it inlined.
     __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
     // Overflow test (preserve left, right, and IP);
     const Register temp = locs.temp(0).reg();
     __ Lsl(temp, left, IP);
-    __ cmp(left, ShifterOperand(temp, ASR, IP));
+    __ cmp(left, Operand(temp, ASR, IP));
     __ b(deopt, NE);  // Overflow.
     // Shift for result now we know there is no overflow.
     __ Lsl(result, left, IP);
   }
 }
 
 
 LocationSummary* BinarySmiOpInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 2;
@@ skipping 77 matching lines @@
           __ SubImmediateSetFlags(result, left, imm);
           __ b(deopt, VS);
         }
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
         const intptr_t value = Smi::Cast(constant).Value();
         if (deopt == NULL) {
           if (value == 2) {
-            __ mov(result, ShifterOperand(left, LSL, 1));
+            __ mov(result, Operand(left, LSL, 1));
           } else {
             __ LoadImmediate(IP, value);
             __ mul(result, left, IP);
           }
         } else {
           if (value == 2) {
-            __ mov(IP, ShifterOperand(left, ASR, 31));  // IP = sign of left.
-            __ mov(result, ShifterOperand(left, LSL, 1));
+            __ mov(IP, Operand(left, ASR, 31));  // IP = sign of left.
+            __ mov(result, Operand(left, LSL, 1));
             // IP: result bits 32..63.
-            __ cmp(IP, ShifterOperand(result, ASR, 31));
+            __ cmp(IP, Operand(result, ASR, 31));
             __ b(deopt, NE);
           } else {
             if (TargetCPUFeatures::arm_version() == ARMv7) {
               __ LoadImmediate(IP, value);
               __ smull(result, IP, left, IP);
               // IP: result bits 32..63.
-              __ cmp(IP, ShifterOperand(result, ASR, 31));
+              __ cmp(IP, Operand(result, ASR, 31));
               __ b(deopt, NE);
             } else {
               const QRegister qtmp = locs()->temp(0).fpu_reg();
               const DRegister dtmp0 = EvenDRegisterOf(qtmp);
               const DRegister dtmp1 = OddDRegisterOf(qtmp);
               __ LoadImmediate(IP, value);
               __ CheckMultSignedOverflow(left, IP, result, dtmp0, dtmp1, deopt);
               __ mul(result, left, IP);
             }
           }
         }
         break;
       }
       case Token::kTRUNCDIV: {
         const intptr_t value = Smi::Cast(constant).Value();
         if (value == 1) {
           __ MoveRegister(result, left);
           break;
         } else if (value == -1) {
           // Check the corner case of dividing the 'MIN_SMI' with -1, in which
           // case we cannot negate the result.
           __ CompareImmediate(left, 0x80000000);
           __ b(deopt, EQ);
-          __ rsb(result, left, ShifterOperand(0));
+          __ rsb(result, left, Operand(0));
           break;
         }
         ASSERT(Utils::IsPowerOfTwo(Utils::Abs(value)));
         const intptr_t shift_count =
             Utils::ShiftForPowerOfTwo(Utils::Abs(value)) + kSmiTagSize;
         ASSERT(kSmiTagSize == 1);
-        __ mov(IP, ShifterOperand(left, ASR, 31));
+        __ mov(IP, Operand(left, ASR, 31));
         ASSERT(shift_count > 1);  // 1, -1 case handled above.
         const Register temp = locs()->temp(0).reg();
-        __ add(temp, left, ShifterOperand(IP, LSR, 32 - shift_count));
+        __ add(temp, left, Operand(IP, LSR, 32 - shift_count));
         ASSERT(shift_count > 0);
-        __ mov(result, ShifterOperand(temp, ASR, shift_count));
+        __ mov(result, Operand(temp, ASR, shift_count));
         if (value < 0) {
-          __ rsb(result, result, ShifterOperand(0));
+          __ rsb(result, result, Operand(0));
         }
         __ SmiTag(result);
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
-        ShifterOperand shifter_op;
-        if (ShifterOperand::CanHold(imm, &shifter_op)) {
-          __ and_(result, left, shifter_op);
-        } else if (ShifterOperand::CanHold(~imm, &shifter_op)) {
-          __ bic(result, left, shifter_op);
+        Operand o;
+        if (Operand::CanHold(imm, &o)) {
+          __ and_(result, left, o);
+        } else if (Operand::CanHold(~imm, &o)) {
+          __ bic(result, left, o);
         } else {
           __ LoadImmediate(IP, imm);
-          __ and_(result, left, ShifterOperand(IP));
+          __ and_(result, left, Operand(IP));
         }
         break;
       }
       case Token::kBIT_OR: {
         // No overflow check.
-        ShifterOperand shifter_op;
-        if (ShifterOperand::CanHold(imm, &shifter_op)) {
-          __ orr(result, left, shifter_op);
+        Operand o;
+        if (Operand::CanHold(imm, &o)) {
+          __ orr(result, left, o);
         } else {
           __ LoadImmediate(IP, imm);
-          __ orr(result, left, ShifterOperand(IP));
+          __ orr(result, left, Operand(IP));
         }
         break;
       }
       case Token::kBIT_XOR: {
         // No overflow check.
-        ShifterOperand shifter_op;
-        if (ShifterOperand::CanHold(imm, &shifter_op)) {
-          __ eor(result, left, shifter_op);
+        Operand o;
+        if (Operand::CanHold(imm, &o)) {
+          __ eor(result, left, o);
         } else {
           __ LoadImmediate(IP, imm);
-          __ eor(result, left, ShifterOperand(IP));
+          __ eor(result, left, Operand(IP));
         }
         break;
       }
       case Token::kSHR: {
         // sarl operation masks the count to 5 bits.
         const intptr_t kCountLimit = 0x1F;
         intptr_t value = Smi::Cast(constant).Value();
 
         if (value == 0) {
           // TODO(vegorov): should be handled outside.
@@ skipping 20 matching lines @@
         break;
     }
     return;
   }
 
   const Register right = locs()->in(1).reg();
   Range* right_range = this->right()->definition()->range();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
-        __ add(result, left, ShifterOperand(right));
+        __ add(result, left, Operand(right));
       } else {
-        __ adds(result, left, ShifterOperand(right));
+        __ adds(result, left, Operand(right));
         __ b(deopt, VS);
       }
       break;
     }
     case Token::kSUB: {
       if (deopt == NULL) {
-        __ sub(result, left, ShifterOperand(right));
+        __ sub(result, left, Operand(right));
       } else {
-        __ subs(result, left, ShifterOperand(right));
+        __ subs(result, left, Operand(right));
         __ b(deopt, VS);
       }
       break;
     }
     case Token::kMUL: {
       __ Asr(IP, left, kSmiTagSize);  // SmiUntag left into IP.
       if (deopt == NULL) {
         __ mul(result, IP, right);
       } else {
         if (TargetCPUFeatures::arm_version() == ARMv7) {
           __ smull(result, IP, IP, right);
           // IP: result bits 32..63.
-          __ cmp(IP, ShifterOperand(result, ASR, 31));
+          __ cmp(IP, Operand(result, ASR, 31));
           __ b(deopt, NE);
         } else {
           const QRegister qtmp = locs()->temp(0).fpu_reg();
           const DRegister dtmp0 = EvenDRegisterOf(qtmp);
           const DRegister dtmp1 = OddDRegisterOf(qtmp);
           __ CheckMultSignedOverflow(IP, right, result, dtmp0, dtmp1, deopt);
           __ mul(result, IP, right);
         }
       }
       break;
     }
     case Token::kBIT_AND: {
       // No overflow check.
-      __ and_(result, left, ShifterOperand(right));
+      __ and_(result, left, Operand(right));
       break;
     }
     case Token::kBIT_OR: {
       // No overflow check.
-      __ orr(result, left, ShifterOperand(right));
+      __ orr(result, left, Operand(right));
       break;
     }
     case Token::kBIT_XOR: {
       // No overflow check.
-      __ eor(result, left, ShifterOperand(right));
+      __ eor(result, left, Operand(right));
       break;
     }
     case Token::kTRUNCDIV: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
-        __ cmp(right, ShifterOperand(0));
+        __ cmp(right, Operand(0));
         __ b(deopt, EQ);
       }
       const Register temp = locs()->temp(0).reg();
       const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
       __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
 
       __ IntegerDivide(result, temp, IP, dtemp, DTMP);
 
       // Check the corner case of dividing the 'MIN_SMI' with -1, in which
       // case we cannot tag the result.
       __ CompareImmediate(result, 0x40000000);
       __ b(deopt, EQ);
       __ SmiTag(result);
       break;
     }
     case Token::kMOD: {
       if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
         // Handle divide by zero in runtime.
-        __ cmp(right, ShifterOperand(0));
+        __ cmp(right, Operand(0));
         __ b(deopt, EQ);
       }
       const Register temp = locs()->temp(0).reg();
       const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
       __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
 
       __ IntegerDivide(result, temp, IP, dtemp, DTMP);
 
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
       __ mls(result, IP, result, temp);  // result <- left - right * result
       __ SmiTag(result);
       //  res = left % right;
       //  if (res < 0) {
       //    if (right < 0) {
       //      res = res - right;
       //    } else {
       //      res = res + right;
       //    }
       //  }
       Label done;
-      __ cmp(result, ShifterOperand(0));
+      __ cmp(result, Operand(0));
       __ b(&done, GE);
       // Result is negative, adjust it.
-      __ cmp(right, ShifterOperand(0));
-      __ sub(result, result, ShifterOperand(right), LT);
-      __ add(result, result, ShifterOperand(right), GE);
+      __ cmp(right, Operand(0));
+      __ sub(result, result, Operand(right), LT);
+      __ add(result, result, Operand(right), GE);
       __ Bind(&done);
       break;
     }
     case Token::kSHR: {
       if (CanDeoptimize()) {
         __ CompareImmediate(right, 0);
         __ b(deopt, LT);
       }
       __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
       // sarl operation masks the count to 5 bits.
@@ skipping 45 matching lines @@
 
 
 void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         ICData::kDeoptBinaryDoubleOp);
   intptr_t left_cid = left()->Type()->ToCid();
   intptr_t right_cid = right()->Type()->ToCid();
   const Register left = locs()->in(0).reg();
   const Register right = locs()->in(1).reg();
   if (this->left()->definition() == this->right()->definition()) {
-    __ tst(left, ShifterOperand(kSmiTagMask));
+    __ tst(left, Operand(kSmiTagMask));
   } else if (left_cid == kSmiCid) {
-    __ tst(right, ShifterOperand(kSmiTagMask));
+    __ tst(right, Operand(kSmiTagMask));
   } else if (right_cid == kSmiCid) {
-    __ tst(left, ShifterOperand(kSmiTagMask));
+    __ tst(left, Operand(kSmiTagMask));
   } else {
-    __ orr(IP, left, ShifterOperand(right));
-    __ tst(IP, ShifterOperand(kSmiTagMask));
+    __ orr(IP, left, Operand(right));
+    __ tst(IP, Operand(kSmiTagMask));
   }
   __ b(deopt, EQ);
 }
 
 
 LocationSummary* BoxDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                      bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(isolate) LocationSummary(
@@ skipping 59 matching lines @@
     const Register temp = locs()->temp(0).reg();
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareImmediate(value, reinterpret_cast<intptr_t>(Object::null()));
       __ b(deopt, EQ);
       // It must be double now.
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
     } else {
       Label is_smi, done;
-      __ tst(value, ShifterOperand(kSmiTagMask));
+      __ tst(value, Operand(kSmiTagMask));
       __ b(&is_smi, EQ);
       __ CompareClassId(value, kDoubleCid, temp);
       __ b(deopt, NE);
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
       __ b(&done);
       __ Bind(&is_smi);
       // TODO(regis): Why do we preserve value here but not above?
-      __ mov(IP, ShifterOperand(value, ASR, 1));  // Copy and untag.
+      __ mov(IP, Operand(value, ASR, 1));  // Copy and untag.
       __ vmovsr(STMP, IP);
       __ vcvtdi(result, STMP);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
@@ skipping 47 matching lines @@
 
 
 void UnboxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const QRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat32x4Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat32x4Cid, temp);
     __ b(deopt, NE);
   }
 
   const DRegister dresult0 = EvenDRegisterOf(result);
   __ LoadMultipleDFromOffset(dresult0, 2, value,
       Float32x4::value_offset() - kHeapObjectTag);
 }
 
@@ skipping 50 matching lines @@
 
 
 void UnboxFloat64x2Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const QRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kFloat64x2Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat64x2Cid, temp);
     __ b(deopt, NE);
   }
 
   const DRegister dresult0 = EvenDRegisterOf(result);
   __ LoadMultipleDFromOffset(dresult0, 2, value,
       Float64x2::value_offset() - kHeapObjectTag);
 }
 
@@ skipping 27 matching lines @@
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
-    __ mov(locs->out(0).reg(), ShifterOperand(R0));
+    __ mov(locs->out(0).reg(), Operand(R0));
     compiler->RestoreLiveRegisters(locs);
 
     __ b(exit_label());
   }
 
  private:
   BoxInt32x4Instr* instruction_;
 };
 
 
@@ skipping 33 matching lines @@
 
 
 void UnboxInt32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t value_cid = value()->Type()->ToCid();
   const Register value = locs()->in(0).reg();
   const QRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid != kInt32x4Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, ICData::kDeoptCheckClass);
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kInt32x4Cid, temp);
     __ b(deopt, NE);
   }
 
   const DRegister dresult0 = EvenDRegisterOf(result);
   __ LoadMultipleDFromOffset(dresult0, 2, value,
       Int32x4::value_offset() - kHeapObjectTag);
 }
 
@@ skipping 260 matching lines @@
 
   const Register out = locs()->out(0).reg();
   const Register temp = locs()->temp(0).reg();
 
   // X lane.
   __ vmovrs(out, EvenSRegisterOf(dvalue0));
   __ Lsr(out, out, 31);
   // Y lane.
   __ vmovrs(temp, OddSRegisterOf(dvalue0));
   __ Lsr(temp, temp, 31);
-  __ orr(out, out, ShifterOperand(temp, LSL, 1));
+  __ orr(out, out, Operand(temp, LSL, 1));
   // Z lane.
   __ vmovrs(temp, EvenSRegisterOf(dvalue1));
   __ Lsr(temp, temp, 31);
-  __ orr(out, out, ShifterOperand(temp, LSL, 2));
+  __ orr(out, out, Operand(temp, LSL, 2));
   // W lane.
   __ vmovrs(temp, OddSRegisterOf(dvalue1));
   __ Lsr(temp, temp, 31);
-  __ orr(out, out, ShifterOperand(temp, LSL, 3));
+  __ orr(out, out, Operand(temp, LSL, 3));
   // Tag.
   __ SmiTag(out);
 }
 
 
 LocationSummary* Float32x4ConstructorInstr::MakeLocationSummary(
     Isolate* isolate, bool opt) const {
   const intptr_t kNumInputs = 4;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
@@ skipping 524 matching lines @@
     const DRegister dvalue1 = OddDRegisterOf(q);
 
     const Register out = locs()->out(0).reg();
 
     // Upper 32-bits of X lane.
     __ vmovrs(out, OddSRegisterOf(dvalue0));
     __ Lsr(out, out, 31);
     // Upper 32-bits of Y lane.
     __ vmovrs(TMP, OddSRegisterOf(dvalue1));
     __ Lsr(TMP, TMP, 31);
-    __ orr(out, out, ShifterOperand(TMP, LSL, 1));
+    __ orr(out, out, Operand(TMP, LSL, 1));
     // Tag.
     __ SmiTag(out);
     return;
   }
   ASSERT(representation() == kUnboxedFloat64x2);
   const QRegister r = locs()->out(0).fpu_reg();
 
   const DRegister dvalue0 = EvenDRegisterOf(q);
   const DRegister dvalue1 = OddDRegisterOf(q);
   const DRegister dresult0 = EvenDRegisterOf(r);
@@ skipping 171 matching lines @@
       break;
     case MethodRecognizer::kInt32x4GetFlagZ:
       __ vmovrs(result, svalue2);
       break;
     case MethodRecognizer::kInt32x4GetFlagW:
       __ vmovrs(result, svalue3);
       break;
     default: UNREACHABLE();
   }
 
-  __ tst(result, ShifterOperand(result));
+  __ tst(result, Operand(result));
   __ LoadObject(result, Bool::True(), NE);
   __ LoadObject(result, Bool::False(), EQ);
 }
 
 
 LocationSummary* Int32x4SelectInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(isolate) LocationSummary(
@@ skipping 238 matching lines @@
     __ b(&done);
 
     __ Bind(&are_equal);
     // Check for negative zero: -0.0 is equal 0.0 but min or max must return
     // -0.0 or 0.0 respectively.
     // Check for negative left value (get the sign bit):
     // - min -> left is negative ? left : right.
     // - max -> left is negative ? right : left
     // Check the sign bit.
     __ vmovrrd(IP, temp, left);  // Sign bit is in bit 31 of temp.
-    __ cmp(temp, ShifterOperand(0));
+    __ cmp(temp, Operand(0));
     if (is_min) {
       ASSERT(left == result);
       __ vmovd(result, right, GE);
     } else {
       __ vmovd(result, right, LT);
       ASSERT(left == result);
     }
     __ Bind(&done);
     return;
   }
 
   ASSERT(result_cid() == kSmiCid);
   const Register left = locs()->in(0).reg();
   const Register right = locs()->in(1).reg();
   const Register result = locs()->out(0).reg();
-  __ cmp(left, ShifterOperand(right));
+  __ cmp(left, Operand(right));
   ASSERT(result == left);
   if (is_min) {
-    __ mov(result, ShifterOperand(right), GT);
+    __ mov(result, Operand(right), GT);
   } else {
-    __ mov(result, ShifterOperand(right), LT);
+    __ mov(result, Operand(right), LT);
   }
 }
 
 
 LocationSummary* UnarySmiOpInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   // We make use of 3-operand instructions by not requiring result register
   // to be identical to first input register as on Intel.
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryOp);
-      __ rsbs(result, value, ShifterOperand(0));
+      __ rsbs(result, value, Operand(0));
       __ b(deopt, VS);
       break;
     }
     case Token::kBIT_NOT:
-      __ mvn(result, ShifterOperand(value));
+      __ mvn(result, Operand(value));
       // Remove inverted smi-tag.
-      __ bic(result, result, ShifterOperand(kSmiTagMask));
+      __ bic(result, result, Operand(kSmiTagMask));
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* UnaryDoubleOpInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 394 matching lines @@
   PairLocation* pair = locs()->in(0).AsPairLocation();
   Location in_loc = pair->At(index());
   if (representation() == kUnboxedDouble) {
     const QRegister out = locs()->out(0).fpu_reg();
     const QRegister in = in_loc.fpu_reg();
     __ vmovq(out, in);
   } else {
     ASSERT(representation() == kTagged);
     const Register out = locs()->out(0).reg();
     const Register in = in_loc.reg();
-    __ mov(out, ShifterOperand(in));
+    __ mov(out, Operand(in));
   }
 }
 
 
 LocationSummary* MergedMathInstr::MakeLocationSummary(Isolate* isolate,
                                                       bool opt) const {
   if (kind() == MergedMathInstr::kTruncDivMod) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 2;
     LocationSummary* summary = new(isolate) LocationSummary(
@@ skipping 20 matching lines @@
   if (kind() == MergedMathInstr::kTruncDivMod) {
     const Register left = locs()->in(0).reg();
     const Register right = locs()->in(1).reg();
     ASSERT(locs()->out(0).IsPairLocation());
     PairLocation* pair = locs()->out(0).AsPairLocation();
     const Register result_div = pair->At(0).reg();
     const Register result_mod = pair->At(1).reg();
     Range* right_range = InputAt(1)->definition()->range();
     if ((right_range == NULL) || right_range->Overlaps(0, 0)) {
       // Handle divide by zero in runtime.
-      __ cmp(right, ShifterOperand(0));
+      __ cmp(right, Operand(0));
       __ b(deopt, EQ);
     }
     const Register temp = locs()->temp(0).reg();
     const DRegister dtemp = EvenDRegisterOf(locs()->temp(1).fpu_reg());
 
     __ Asr(temp, left, kSmiTagSize);  // SmiUntag left into temp.
     __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
 
     __ IntegerDivide(result_div, temp, IP, dtemp, DTMP);
 
     // Check the corner case of dividing the 'MIN_SMI' with -1, in which
     // case we cannot tag the result.
     __ CompareImmediate(result_div, 0x40000000);
     __ b(deopt, EQ);
     __ Asr(IP, right, kSmiTagSize);  // SmiUntag right into IP.
     // result_mod <- left - right * result_div.
     __ mls(result_mod, IP, result_div, temp);
     __ SmiTag(result_div);
     __ SmiTag(result_mod);
     // Correct MOD result:
     //  res = left % right;
     //  if (res < 0) {
     //    if (right < 0) {
     //      res = res - right;
     //    } else {
     //      res = res + right;
     //    }
     //  }
     Label done;
-    __ cmp(result_mod, ShifterOperand(0));
+    __ cmp(result_mod, Operand(0));
     __ b(&done, GE);
     // Result is negative, adjust it.
-    __ cmp(right, ShifterOperand(0));
-    __ sub(result_mod, result_mod, ShifterOperand(right), LT);
-    __ add(result_mod, result_mod, ShifterOperand(right), GE);
+    __ cmp(right, Operand(0));
+    __ sub(result_mod, result_mod, Operand(right), LT);
+    __ add(result_mod, result_mod, Operand(right), GE);
     __ Bind(&done);
 
     return;
   }
   if (kind() == MergedMathInstr::kSinCos) {
     UNIMPLEMENTED();
   }
   UNIMPLEMENTED();
 }
 
@@ skipping 82 matching lines @@
   }
 
   ASSERT((unary_checks().GetReceiverClassIdAt(0) != kSmiCid) ||
          (unary_checks().NumberOfChecks() > 1));
   const Register value = locs()->in(0).reg();
   const Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), deopt_reason);
   Label is_ok;
   intptr_t cix = 0;
   if (unary_checks().GetReceiverClassIdAt(cix) == kSmiCid) {
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(&is_ok, EQ);
     cix++;  // Skip first check.
   } else {
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(deopt, EQ);
   }
   __ LoadClassId(temp, value);
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   for (intptr_t i = cix; i < num_checks; i++) {
     ASSERT(unary_checks().GetReceiverClassIdAt(i) != kSmiCid);
     __ CompareImmediate(temp, unary_checks().GetReceiverClassIdAt(i));
     if (i == (num_checks - 1)) {
       __ b(deopt, NE);
     } else {
@@ skipping 11 matching lines @@
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckSmi);
-  __ tst(value, ShifterOperand(kSmiTagMask));
+  __ tst(value, Operand(kSmiTagMask));
   __ b(deopt, NE);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(Isolate* isolate,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 26 matching lines @@
     __ CompareImmediate(length, reinterpret_cast<int32_t>(index.raw()));
     __ b(deopt, LS);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     const Register index = index_loc.reg();
     __ CompareImmediate(index, reinterpret_cast<int32_t>(length.raw()));
     __ b(deopt, CS);
   } else {
     const Register length = length_loc.reg();
     const Register index = index_loc.reg();
-    __ cmp(index, ShifterOperand(length));
+    __ cmp(index, Operand(length));
     __ b(deopt, CS);
   }
 }
 
 
 static void EmitJavascriptIntOverflowCheck(FlowGraphCompiler* compiler,
                                            Label* overflow,
                                            Register result_lo,
                                            Register result_hi) {
   // Compare upper half.
@@ skipping 43 matching lines @@
                       result_lo,
                       value,
                       Mint::value_offset() - kHeapObjectTag);
     // Load high word.
     __ LoadFromOffset(kWord,
                       result_hi,
                       value,
                       Mint::value_offset() - kHeapObjectTag + kWordSize);
   } else if (value_cid == kSmiCid) {
     // Load Smi into result_lo.
-    __ mov(result_lo, ShifterOperand(value));
+    __ mov(result_lo, Operand(value));
     // Untag.
     __ SmiUntag(result_lo);
     __ SignFill(result_hi, result_lo);
   } else {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptUnboxInteger);
     Label is_smi, done;
-    __ tst(value, ShifterOperand(kSmiTagMask));
+    __ tst(value, Operand(kSmiTagMask));
     __ b(&is_smi, EQ);
     __ CompareClassId(value, kMintCid, temp);
     __ b(deopt, NE);
 
     // It's a Mint.
     // Load low word.
     __ LoadFromOffset(kWord,
                       result_lo,
                       value,
                       Mint::value_offset() - kHeapObjectTag);
     // Load high word.
     __ LoadFromOffset(kWord,
                       result_hi,
                       value,
                       Mint::value_offset() - kHeapObjectTag + kWordSize);
     __ b(&done);
 
     // It's a Smi.
     __ Bind(&is_smi);
     // Load Smi into result_lo.
-    __ mov(result_lo, ShifterOperand(value));
+    __ mov(result_lo, Operand(value));
     // Untag.
     __ SmiUntag(result_lo);
     // Sign extend result_lo into result_hi.
     __ SignFill(result_hi, result_lo);
     __ Bind(&done);
   }
 }
 
 
 LocationSummary* BoxIntegerInstr::MakeLocationSummary(Isolate* isolate,
@@ skipping 27 matching lines @@
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            PcDescriptors::kOther,
                            locs);
-    __ mov(locs->out(0).reg(), ShifterOperand(R0));
+    __ mov(locs->out(0).reg(), Operand(R0));
     compiler->RestoreLiveRegisters(locs);
 
     __ b(exit_label());
   }
 
  private:
   BoxIntegerInstr* instruction_;
 };
 
 
@@ skipping 24 matching lines @@
   __ b(&not_smi);
 
   __ Bind(&maybe_neg_smi);
   __ CompareImmediate(value_lo, 0);
   __ b(&not_smi, GE);
   __ CompareImmediate(value_lo, kSmiMin);
   __ b(&not_smi, LT);
 
   // lo is a Smi. Tag it and return.
   __ Bind(&is_smi);
-  __ mov(out_reg, ShifterOperand(value_lo));
+  __ mov(out_reg, Operand(value_lo));
   __ SmiTag(out_reg);
   __ b(&done);
 
   // Not a smi. Box it.
   __ Bind(&not_smi);
   __ TryAllocate(
       Class::ZoneHandle(Isolate::Current()->object_store()->mint_class()),
       slow_path->entry_label(),
       out_reg,
       tmp);
@@ skipping 36 matching lines @@
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
 
   Label* deopt = NULL;
   if (FLAG_throw_on_javascript_int_overflow) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
   }
   switch (op_kind()) {
     case Token::kBIT_AND: {
-      __ and_(out_lo, left_lo, ShifterOperand(right_lo));
-      __ and_(out_hi, left_hi, ShifterOperand(right_hi));
+      __ and_(out_lo, left_lo, Operand(right_lo));
+      __ and_(out_hi, left_hi, Operand(right_hi));
     }
     break;
     case Token::kBIT_OR: {
-      __ orr(out_lo, left_lo, ShifterOperand(right_lo));
-      __ orr(out_hi, left_hi, ShifterOperand(right_hi));
+      __ orr(out_lo, left_lo, Operand(right_lo));
+      __ orr(out_hi, left_hi, Operand(right_hi));
     }
     break;
     case Token::kBIT_XOR: {
-     __ eor(out_lo, left_lo, ShifterOperand(right_lo));
-     __ eor(out_hi, left_hi, ShifterOperand(right_hi));
+     __ eor(out_lo, left_lo, Operand(right_lo));
+     __ eor(out_hi, left_hi, Operand(right_hi));
     }
     break;
     case Token::kADD:
     case Token::kSUB: {
       if (!FLAG_throw_on_javascript_int_overflow) {
         deopt  = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
       }
       if (op_kind() == Token::kADD) {
-        __ adds(out_lo, left_lo, ShifterOperand(right_lo));
-        __ adcs(out_hi, left_hi, ShifterOperand(right_hi));
+        __ 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, ShifterOperand(right_lo));
-        __ sbcs(out_hi, left_hi, ShifterOperand(right_hi));
+        __ subs(out_lo, left_lo, Operand(right_lo));
+        __ sbcs(out_hi, left_hi, Operand(right_hi));
       }
       // Deopt on overflow.
       __ b(deopt, VS);
       break;
     }
     default:
       UNREACHABLE();
     break;
   }
   if (FLAG_throw_on_javascript_int_overflow) {
@@ skipping 26 matching lines @@
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
   Register temp = locs()->temp(0).reg();
 
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
   Label done;
 
   // Early out if shift is 0.
   __ CompareImmediate(shift, 0);
-  __ mov(out_lo, ShifterOperand(left_lo));
-  __ mov(out_hi, ShifterOperand(left_hi));
+  __ mov(out_lo, Operand(left_lo));
+  __ mov(out_hi, Operand(left_hi));
   __ b(&done, EQ);
 
   // Untag shift count.
   __ SmiUntag(shift);
 
   // Deopt if shift is negative.
   __ CompareImmediate(shift, 1);
   __ b(deopt, LT);
 
   // Deopt if shift is larger than 63.
   __ CompareImmediate(shift, 63);
   __ b(deopt, GT);
 
   switch (op_kind()) {
     case Token::kSHR: {
-      __ cmp(shift, ShifterOperand(32));
+      __ cmp(shift, Operand(32));
 
-      __ mov(out_lo, ShifterOperand(out_hi), HI);
+      __ mov(out_lo, Operand(out_hi), HI);
       __ Asr(out_hi, out_hi, 31, HI);
-      __ sub(shift, shift, ShifterOperand(32), HI);
+      __ sub(shift, shift, Operand(32), HI);
 
-      __ rsb(temp, shift, ShifterOperand(32));
-      __ mov(temp, ShifterOperand(out_hi, LSL, temp));
-      __ orr(out_lo, temp, ShifterOperand(out_lo, LSR, shift));
+      __ rsb(temp, shift, Operand(32));
+      __ mov(temp, Operand(out_hi, LSL, temp));
+      __ orr(out_lo, temp, Operand(out_lo, LSR, shift));
       __ Asr(out_hi, out_hi, shift);
       break;
     }
     case Token::kSHL: {
-      __ rsbs(temp, shift, ShifterOperand(32));
-      __ sub(temp, shift, ShifterOperand(32), MI);
-      __ mov(out_hi, ShifterOperand(out_lo, LSL, temp), MI);
-      __ mov(out_hi, ShifterOperand(out_hi, LSL, shift), PL);
-      __ orr(out_hi, out_hi, ShifterOperand(out_lo, LSR, temp), PL);
-      __ mov(out_lo, ShifterOperand(out_lo, LSL, shift));
+      __ rsbs(temp, shift, Operand(32));
+      __ sub(temp, shift, Operand(32), MI);
+      __ mov(out_hi, Operand(out_lo, LSL, temp), MI);
+      __ mov(out_hi, Operand(out_hi, LSL, shift), PL);
+      __ orr(out_hi, out_hi, Operand(out_lo, LSR, temp), PL);
+      __ mov(out_lo, Operand(out_lo, LSL, shift));
 
       // Check for overflow.
 
       // Copy high word from output.
-      __ mov(temp, ShifterOperand(out_hi));
+      __ mov(temp, Operand(out_hi));
       // Shift copy right.
       __ Asr(temp, temp, shift);
       // Compare with high word from input.
-      __ cmp(temp, ShifterOperand(left_hi));
+      __ cmp(temp, Operand(left_hi));
       // Overflow if they aren't equal.
       __ b(deopt, NE);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 
   __ Bind(&done);
@@ skipping 25 matching lines @@
 
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
 
   Label* deopt = NULL;
 
   if (FLAG_throw_on_javascript_int_overflow) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryMintOp);
   }
-  __ mvn(out_lo, ShifterOperand(left_lo));
-  __ mvn(out_hi, ShifterOperand(left_hi));
+  __ mvn(out_lo, Operand(left_lo));
+  __ mvn(out_hi, Operand(left_hi));
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptIntOverflowCheck(compiler, deopt, out_lo, out_hi);
   }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary(Isolate* isolate,
                                                  bool opt) const {
   return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kCall);
 }
@@ skipping 88 matching lines @@
 LocationSummary* CurrentContextInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   return LocationSummary::Make(isolate,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ mov(locs()->out(0).reg(), ShifterOperand(CTX));
+  __ mov(locs()->out(0).reg(), Operand(CTX));
 }
 
 
 LocationSummary* StrictCompareInstr::MakeLocationSummary(Isolate* isolate,
                                                          bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (needs_number_check()) {
     LocationSummary* locs = new(isolate) LocationSummary(
         isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
@@ skipping 71 matching lines @@
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
 
   __ LoadObject(result, Bool::True());
-  __ cmp(result, ShifterOperand(value));
+  __ cmp(result, Operand(value));
   __ LoadObject(result, Bool::False(), EQ);
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls()));
   const ExternalLabel label(stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM