Rename ShifterOperand to Operand on ARM.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/cpu.h"
@@ skipping 25 matching lines @@
 //   SP + 4*R4 : address of return value.
 //   R5 : address of the runtime function to call.
 //   R4 : number of arguments to the call.
 void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
   const intptr_t exitframe_last_param_slot_from_fp = 2;
 
-  __ mov(IP, ShifterOperand(0));
+  __ mov(IP, Operand(0));
   __ Push(IP);  // Push 0 for the PC marker.
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to Dart VM C++ code.
   __ StoreToOffset(kWord, SP, R0, Isolate::top_exit_frame_info_offset());
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(kWord, CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing runtime code.
-  __ mov(CTX, ShifterOperand(R0));
+  __ mov(CTX, Operand(R0));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(kWord, R6, CTX, Isolate::vm_tag_offset());
     __ CompareImmediate(R6, VMTag::kScriptTagId);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
 #endif
 
   // Mark that the isolate is executing VM code.
   __ StoreToOffset(kWord, R5, CTX, Isolate::vm_tag_offset());
 
   // Reserve space for arguments and align frame before entering C++ world.
   // NativeArguments are passed in registers.
   ASSERT(sizeof(NativeArguments) == 4 * kWordSize);
   __ ReserveAlignedFrameSpace(0);
 
   // Pass NativeArguments structure by value and call runtime.
   // Registers R0, R1, R2, and R3 are used.
 
   ASSERT(isolate_offset == 0 * kWordSize);
   // Set isolate in NativeArgs: R0 already contains CTX.
 
   // There are no runtime calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
-  __ mov(R1, ShifterOperand(R4));  // Set argc in NativeArguments.
+  __ mov(R1, Operand(R4));  // Set argc in NativeArguments.
 
   ASSERT(argv_offset == 2 * kWordSize);
-  __ add(R2, FP, ShifterOperand(R4, LSL, 2));  // Compute argv.
+  __ add(R2, FP, Operand(R4, LSL, 2));  // Compute argv.
   // Set argv in NativeArguments.
   __ AddImmediate(R2, exitframe_last_param_slot_from_fp * kWordSize);
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ add(R3, R2, ShifterOperand(kWordSize));  // Retval is next to 1st argument.
+  __ add(R3, R2, Operand(kWordSize));  // Retval is next to 1st argument.
 
   // Call runtime or redirection via simulator.
   __ blx(R5);
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R2, VMTag::kScriptTagId);
   __ StoreToOffset(kWord, R2, CTX, Isolate::vm_tag_offset());
 
   // Reset exit frame information in Isolate structure.
   __ LoadImmediate(R2, 0);
   __ StoreToOffset(kWord, R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(kWord, R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
   __ StoreToOffset(kWord, R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
-  __ mov(CTX, ShifterOperand(R2));
+  __ mov(CTX, Operand(R2));
 
   __ LeaveFrame((1 << FP) | (1 << LR));
   // Adjust SP for the empty PC marker.
   __ AddImmediate(SP, kWordSize);
   __ Ret();
 }
 
 
 // Print the stop message.
 DEFINE_LEAF_RUNTIME_ENTRY(void, PrintStopMessage, 1, const char* message) {
@@ skipping 19 matching lines @@
 //   SP : address of return value.
 //   R5 : address of the native function to call.
 //   R2 : address of first argument in argument array.
 //   R1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallNativeCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
-  __ mov(IP, ShifterOperand(0));
+  __ mov(IP, Operand(0));
   __ Push(IP);  // Push 0 for the PC marker.
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ StoreToOffset(kWord, SP, R0, Isolate::top_exit_frame_info_offset());
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(kWord, CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing native code.
-  __ mov(CTX, ShifterOperand(R0));
+  __ mov(CTX, Operand(R0));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(kWord, R6, CTX, Isolate::vm_tag_offset());
     __ CompareImmediate(R6, VMTag::kScriptTagId);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
@@ skipping 15 matching lines @@
 
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: R1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: R2 already contains argv.
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ add(R3, FP, ShifterOperand(3 * kWordSize));  // Set retval in NativeArgs.
+  __ add(R3, FP, Operand(3 * kWordSize));  // Set retval in NativeArgs.
 
   // TODO(regis): Should we pass the structure by value as in runtime calls?
   // It would require changing Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ stm(IA, SP,  (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3));
-  __ mov(R0, ShifterOperand(SP));  // Pass the pointer to the NativeArguments.
+  __ mov(R0, Operand(SP));  // Pass the pointer to the NativeArguments.
 
   // Call native function (setsup scope if not leaf function).
   Label leaf_call;
   Label done;
   __ TestImmediate(R1, NativeArguments::AutoSetupScopeMask());
   __ b(&leaf_call, EQ);
 
-  __ mov(R1, ShifterOperand(R5));  // Pass the function entrypoint to call.
+  __ mov(R1, Operand(R5));  // Pass the function entrypoint to call.
   // Call native function invocation wrapper or redirection via simulator.
 #if defined(USING_SIMULATOR)
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
   __ LoadImmediate(R2, entry);
   __ blx(R2);
 #else
   __ BranchLink(&NativeEntry::NativeCallWrapperLabel());
 #endif
@@ skipping 14 matching lines @@
   __ StoreToOffset(kWord, R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(kWord, R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
   __ StoreToOffset(kWord, R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
-  __ mov(CTX, ShifterOperand(R2));
+  __ mov(CTX, Operand(R2));
 
   __ LeaveFrame((1 << FP) | (1 << LR));
   // Adjust SP for the empty PC marker.
   __ AddImmediate(SP, kWordSize);
   __ Ret();
 }
 
 
 // Input parameters:
 //   LR : return address.
 //   SP : address of return value.
 //   R5 : address of the native function to call.
 //   R2 : address of first argument in argument array.
 //   R1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallBootstrapCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
-  __ mov(IP, ShifterOperand(0));
+  __ mov(IP, Operand(0));
   __ Push(IP);  // Push 0 for the PC marker.
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Load current Isolate pointer from Context structure into R0.
   __ ldr(R0, FieldAddress(CTX, Context::isolate_offset()));
 
   // Save exit frame information to enable stack walking as we are about
   // to transition to native code.
   __ StoreToOffset(kWord, SP, R0, Isolate::top_exit_frame_info_offset());
 
   // Save current Context pointer into Isolate structure.
   __ StoreToOffset(kWord, CTX, R0, Isolate::top_context_offset());
 
   // Cache Isolate pointer into CTX while executing native code.
-  __ mov(CTX, ShifterOperand(R0));
+  __ mov(CTX, Operand(R0));
 
 #if defined(DEBUG)
   { Label ok;
     // Check that we are always entering from Dart code.
     __ LoadFromOffset(kWord, R6, CTX, Isolate::vm_tag_offset());
     __ CompareImmediate(R6, VMTag::kScriptTagId);
     __ b(&ok, EQ);
     __ Stop("Not coming from Dart code.");
     __ Bind(&ok);
   }
@@ skipping 15 matching lines @@
 
   // There are no native calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   ASSERT(argc_tag_offset == 1 * kWordSize);
   // Set argc in NativeArguments: R1 already contains argc.
 
   ASSERT(argv_offset == 2 * kWordSize);
   // Set argv in NativeArguments: R2 already contains argv.
 
   ASSERT(retval_offset == 3 * kWordSize);
-  __ add(R3, FP, ShifterOperand(3 * kWordSize));  // Set retval in NativeArgs.
+  __ add(R3, FP, Operand(3 * kWordSize));  // Set retval in NativeArgs.
 
   // TODO(regis): Should we pass the structure by value as in runtime calls?
   // It would require changing Dart API for native functions.
   // For now, space is reserved on the stack and we pass a pointer to it.
   __ stm(IA, SP,  (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3));
-  __ mov(R0, ShifterOperand(SP));  // Pass the pointer to the NativeArguments.
+  __ mov(R0, Operand(SP));  // Pass the pointer to the NativeArguments.
 
   // Call native function or redirection via simulator.
   __ blx(R5);
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(R2, VMTag::kScriptTagId);
   __ StoreToOffset(kWord, R2, CTX, Isolate::vm_tag_offset());
 
   // Reset exit frame information in Isolate structure.
   __ LoadImmediate(R2, 0);
   __ StoreToOffset(kWord, R2, CTX, Isolate::top_exit_frame_info_offset());
 
   // Load Context pointer from Isolate structure into R2.
   __ LoadFromOffset(kWord, R2, CTX, Isolate::top_context_offset());
 
   // Reset Context pointer in Isolate structure.
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
   __ StoreToOffset(kWord, R3, CTX, Isolate::top_context_offset());
 
   // Cache Context pointer into CTX while executing Dart code.
-  __ mov(CTX, ShifterOperand(R2));
+  __ mov(CTX, Operand(R2));
 
   __ LeaveFrame((1 << FP) | (1 << LR));
   // Adjust SP for the empty PC marker.
   __ AddImmediate(SP, kWordSize);
   __ Ret();
 }
 
 
 // Input parameters:
 //   R4: arguments descriptor array.
@@ skipping 43 matching lines @@
 //   FP[kParamEndSlotFromFp + 1]: last argument.
 static void PushArgumentsArray(Assembler* assembler) {
   // Allocate array to store arguments of caller.
   __ LoadImmediate(R1, reinterpret_cast<intptr_t>(Object::null()));
   // R1: null element type for raw Array.
   // R2: smi-tagged argument count, may be zero.
   __ BranchLink(&StubCode::AllocateArrayLabel());
   // R0: newly allocated array.
   // R2: smi-tagged argument count, may be zero (was preserved by the stub).
   __ Push(R0);  // Array is in R0 and on top of stack.
-  __ add(R1, FP, ShifterOperand(R2, LSL, 1));
+  __ add(R1, FP, Operand(R2, LSL, 1));
   __ AddImmediate(R1, kParamEndSlotFromFp * kWordSize);
   __ AddImmediate(R3, R0, Array::data_offset() - kHeapObjectTag);
   // R1: address of first argument on stack.
   // R3: address of first argument in array.
   Label loop;
   __ Bind(&loop);
-  __ subs(R2, R2, ShifterOperand(Smi::RawValue(1)));  // R2 is Smi.
+  __ subs(R2, R2, Operand(Smi::RawValue(1)));  // R2 is Smi.
   __ ldr(IP, Address(R1, 0), PL);
   __ str(IP, Address(R3, 0), PL);
   __ AddImmediate(R1, -kWordSize, PL);
   __ AddImmediate(R3, kWordSize, PL);
   __ b(&loop, PL);
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
@@ skipping 23 matching lines @@
 //   +------------------+
 //   | PC marker        |
 //   +------------------+
 //   | ...              | <- SP of optimized frame
 //
 // Parts of the code cannot GC, part of the code can GC.
 static void GenerateDeoptimizationSequence(Assembler* assembler,
                                            bool preserve_result) {
   // DeoptimizeCopyFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
-  __ mov(IP, ShifterOperand(LR));
-  __ mov(LR, ShifterOperand(0));
+  __ mov(IP, Operand(LR));
+  __ mov(LR, Operand(0));
   __ EnterFrame((1 << PP) | (1 << FP) | (1 << IP) | (1 << LR), 0);
   // The code in this frame may not cause GC. kDeoptimizeCopyFrameRuntimeEntry
   // and kDeoptimizeFillFrameRuntimeEntry are leaf runtime calls.
   const intptr_t saved_result_slot_from_fp =
       kFirstLocalSlotFromFp + 1 - (kNumberOfCpuRegisters - R0);
   // Result in R0 is preserved as part of pushing all registers below.
 
   // TODO(regis): Should we align the stack before pushing the fpu registers?
   // If we do, saved_r0_offset_from_fp is not constant anymore.
 
   // Push registers in their enumeration order: lowest register number at
   // lowest address.
   __ PushList(kAllCpuRegistersList);
 
   if (TargetCPUFeatures::vfp_supported()) {
     ASSERT(kFpuRegisterSize == 4 * kWordSize);
     if (kNumberOfDRegisters > 16) {
       __ vstmd(DB_W, SP, D16, kNumberOfDRegisters - 16);
       __ vstmd(DB_W, SP, D0, 16);
     } else {
       __ vstmd(DB_W, SP, D0, kNumberOfDRegisters);
     }
   } else {
     __ AddImmediate(SP, SP, -kNumberOfFpuRegisters * kFpuRegisterSize);
   }
 
-  __ mov(R0, ShifterOperand(SP));  // Pass address of saved registers block.
+  __ mov(R0, Operand(SP));  // Pass address of saved registers block.
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeCopyFrameRuntimeEntry, 1);
   // Result (R0) is stack-size (FP - SP) in bytes.
 
   if (preserve_result) {
     // Restore result into R1 temporarily.
     __ ldr(R1, Address(FP, saved_result_slot_from_fp * kWordSize));
   }
 
   __ LeaveDartFrame();
-  __ sub(SP, FP, ShifterOperand(R0));
+  __ sub(SP, FP, Operand(R0));
 
   // DeoptimizeFillFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
-  __ mov(IP, ShifterOperand(LR));
-  __ mov(LR, ShifterOperand(0));
+  __ mov(IP, Operand(LR));
+  __ mov(LR, Operand(0));
   __ EnterFrame((1 << PP) | (1 << FP) | (1 << IP) | (1 << LR), 0);
-  __ mov(R0, ShifterOperand(FP));  // Get last FP address.
+  __ mov(R0, Operand(FP));  // Get last FP address.
   if (preserve_result) {
     __ Push(R1);  // Preserve result as first local.
   }
   __ ReserveAlignedFrameSpace(0);
   __ CallRuntime(kDeoptimizeFillFrameRuntimeEntry, 1);  // Pass last FP in R0.
   if (preserve_result) {
     // Restore result into R1.
     __ ldr(R1, Address(FP, kFirstLocalSlotFromFp * kWordSize));
   }
   // Code above cannot cause GC.
   __ LeaveDartFrame();
 
   // Frame is fully rewritten at this point and it is safe to perform a GC.
   // Materialize any objects that were deferred by FillFrame because they
   // require allocation.
   __ EnterStubFrame();
   if (preserve_result) {
     __ Push(R1);  // Preserve result, it will be GC-d here.
   }
   __ PushObject(Smi::ZoneHandle());  // Space for the result.
   __ CallRuntime(kDeoptimizeMaterializeRuntimeEntry, 0);
   // Result tells stub how many bytes to remove from the expression stack
   // of the bottom-most frame. They were used as materialization arguments.
   __ Pop(R1);
   if (preserve_result) {
     __ Pop(R0);  // Restore result.
   }
   __ LeaveStubFrame();
   // Remove materialization arguments.
-  __ add(SP, SP, ShifterOperand(R1, ASR, kSmiTagSize));
+  __ add(SP, SP, Operand(R1, ASR, kSmiTagSize));
   __ Ret();
 }
 
 
 void StubCode::GenerateDeoptimizeLazyStub(Assembler* assembler) {
   // Correct return address to point just after the call that is being
   // deoptimized.
   __ AddImmediate(LR, -CallPattern::LengthInBytes());
   GenerateDeoptimizationSequence(assembler, true);  // Preserve R0.
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   GenerateDeoptimizationSequence(assembler, false);  // Don't preserve R0.
 }
 
 
 void StubCode::GenerateMegamorphicMissStub(Assembler* assembler) {
   __ EnterStubFrame();
 
   // Load the receiver.
   __ ldr(R2, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
-  __ add(IP, FP, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
+  __ add(IP, FP, Operand(R2, LSL, 1));  // R2 is Smi.
   __ ldr(R6, Address(IP, kParamEndSlotFromFp * kWordSize));
 
   // Preserve IC data and arguments descriptor.
   __ PushList((1 << R4) | (1 << R5));
 
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 24 matching lines @@
 // The newly allocated object is returned in R0.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   Label slow_case;
 
   // Compute the size to be allocated, it is based on the array length
   // and is computed as:
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
   __ MoveRegister(R3, R2);   // Array length.
 
   // Check that length is a positive Smi.
-  __ tst(R3, ShifterOperand(kSmiTagMask));
+  __ tst(R3, Operand(kSmiTagMask));
   __ b(&slow_case, NE);
-  __ cmp(R3, ShifterOperand(0));
+  __ cmp(R3, Operand(0));
   __ b(&slow_case, LT);
 
   // Check for maximum allowed length.
   const intptr_t max_len =
       reinterpret_cast<int32_t>(Smi::New(Array::kMaxElements));
   __ CompareImmediate(R3, max_len);
   __ b(&slow_case, GT);
 
   const intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
   __ LoadImmediate(R8, fixed_size);
-  __ add(R8, R8, ShifterOperand(R3, LSL, 1));  // R3 is  a Smi.
+  __ add(R8, R8, Operand(R3, LSL, 1));  // R3 is  a Smi.
   ASSERT(kSmiTagShift == 1);
-  __ bic(R8, R8, ShifterOperand(kObjectAlignment - 1));
+  __ bic(R8, R8, Operand(kObjectAlignment - 1));
 
   // R8: Allocation size.
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   __ LoadImmediate(R6, heap->TopAddress());
   __ ldr(R0, Address(R6, 0));  // Potential new object start.
-  __ adds(R7, R0, ShifterOperand(R8));  // Potential next object start.
+  __ adds(R7, R0, Operand(R8));  // Potential next object start.
   __ b(&slow_case, VS);
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
   // R7: potential next object start.
   // R8: allocation size.
   __ LoadImmediate(R3, heap->EndAddress());
   __ ldr(R3, Address(R3, 0));
-  __ cmp(R7, ShifterOperand(R3));
+  __ cmp(R7, Operand(R3));
   __ b(&slow_case, 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));
   __ UpdateAllocationStatsWithSize(kArrayCid, R8, R4);
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R7: new object end address.
   // R8: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
     const Class& cls = Class::Handle(isolate->object_store()->array_class());
 
     __ CompareImmediate(R8, RawObject::SizeTag::kMaxSizeTag);
-    __ mov(R8, ShifterOperand(R8, LSL, shift), LS);
-    __ mov(R8, ShifterOperand(0), HI);
+    __ mov(R8, Operand(R8, LSL, shift), LS);
+    __ mov(R8, Operand(0), HI);
 
     // Get the class index and insert it into the tags.
     // R8: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cls.id()));
-    __ orr(R8, R8, ShifterOperand(TMP));
+    __ orr(R8, R8, Operand(TMP));
     __ str(R8, FieldAddress(R0, Array::tags_offset()));  // Store tags.
   }
 
   // R0: new object start as a tagged pointer.
   // R7: new object end address.
   // Store the type argument field.
   __ StoreIntoObjectNoBarrier(R0,
                               FieldAddress(R0, Array::type_arguments_offset()),
                               R1);
 
   // Set the length field.
   __ StoreIntoObjectNoBarrier(R0,
                               FieldAddress(R0, Array::length_offset()),
                               R2);
 
   // Initialize all array elements to raw_null.
   // 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);
 
   __ Ret();  // Returns the newly allocated object in R0.
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ PushList((1 << R1) | (1 << R2) | (1 << IP));
   __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   // Pop arguments; result is popped in IP.
   __ PopList((1 << R1) | (1 << R2) | (1 << IP));  // R2 is restored.
-  __ mov(R0, ShifterOperand(IP));
+  __ mov(R0, Operand(IP));
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   LR : points to return address.
 //   R0 : entrypoint of the Dart function to call.
 //   R1 : arguments descriptor array.
 //   R2 : arguments array.
 //   R3 : new context containing the current isolate pointer.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
   __ EnterFrame((1 << FP) | (1 << LR), 0);
 
   // Save new context and C++ ABI callee-saved registers.
   const intptr_t kNewContextOffsetFromFp =
       -(1 + kAbiPreservedCpuRegCount) * kWordSize;
   __ PushList((1 << R3) | kAbiPreservedCpuRegs);
 
   const DRegister firstd = EvenDRegisterOf(kAbiFirstPreservedFpuReg);
   if (TargetCPUFeatures::vfp_supported()) {
     ASSERT(2 * kAbiPreservedFpuRegCount < 16);
     // Save FPU registers. 2 D registers per Q register.
     __ vstmd(DB_W, SP, firstd, 2 * kAbiPreservedFpuRegCount);
   } else {
-    __ sub(SP, SP,
-           ShifterOperand(kAbiPreservedFpuRegCount * kFpuRegisterSize));
+    __ sub(SP, SP, Operand(kAbiPreservedFpuRegCount * kFpuRegisterSize));
   }
 
   // We now load the pool pointer(PP) as we are about to invoke dart code and we
   // could potentially invoke some intrinsic functions which need the PP to be
   // set up.
   __ LoadPoolPointer();
 
   // The new Context structure contains a pointer to the current Isolate
   // structure. Cache the Context pointer in the CTX register so that it is
   // available in generated code and calls to Isolate::Current() need not be
@@ skipping 49 matching lines @@
   Label push_arguments;
   Label done_push_arguments;
   __ CompareImmediate(R5, 0);  // check if there are arguments.
   __ b(&done_push_arguments, EQ);
   __ LoadImmediate(R1, 0);
   __ Bind(&push_arguments);
   __ ldr(R3, Address(R2));
   __ Push(R3);
   __ AddImmediate(R2, kWordSize);
   __ AddImmediate(R1, 1);
-  __ cmp(R1, ShifterOperand(R5));
+  __ cmp(R1, Operand(R5));
   __ b(&push_arguments, LT);
   __ Bind(&done_push_arguments);
 
   // Call the Dart code entrypoint.
   __ blx(R0);  // R4 is the arguments descriptor array.
 
   // Read the saved new Context pointer.
   __ ldr(CTX, Address(FP, kNewContextOffsetFromFp));
   __ ldr(CTX, Address(CTX, VMHandles::kOffsetOfRawPtrInHandle));
 
@@ skipping 13 matching lines @@
 
   // Restore the current VMTag from the stack.
   __ Pop(R4);
   __ StoreToOffset(kWord, R4, CTX, Isolate::vm_tag_offset());
 
   // Restore C++ ABI callee-saved registers.
   if (TargetCPUFeatures::vfp_supported()) {
     // Restore FPU registers. 2 D registers per Q register.
     __ vldmd(IA_W, SP, firstd, 2 * kAbiPreservedFpuRegCount);
   } else {
-    __ add(SP, SP,
-       ShifterOperand(kAbiPreservedFpuRegCount * kFpuRegisterSize));
+    __ AddImmediate(SP, kAbiPreservedFpuRegCount * kFpuRegisterSize);
   }
   // Restore CPU registers.
   __ PopList((1 << R3) | kAbiPreservedCpuRegs);  // Ignore restored R3.
 
   // Restore the frame pointer and return.
   __ LeaveFrame((1 << FP) | (1 << LR));
   __ Ret();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 //   R1: number of context variables.
 // Output:
 //   R0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   if (FLAG_inline_alloc) {
     const Class& context_class = Class::ZoneHandle(Object::context_class());
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     // First compute the rounded instance size.
     // R1: number of context variables.
     intptr_t fixed_size = sizeof(RawContext) + kObjectAlignment - 1;
     __ LoadImmediate(R2, fixed_size);
-    __ add(R2, R2, ShifterOperand(R1, LSL, 2));
+    __ add(R2, R2, Operand(R1, LSL, 2));
     ASSERT(kSmiTagShift == 1);
-    __ bic(R2, R2, ShifterOperand(kObjectAlignment - 1));
+    __ bic(R2, R2, Operand(kObjectAlignment - 1));
 
     // Now allocate the object.
     // R1: number of context variables.
     // R2: object size.
     __ LoadImmediate(R5, heap->TopAddress());
     __ ldr(R0, Address(R5, 0));
-    __ add(R3, R2, ShifterOperand(R0));
+    __ add(R3, R2, Operand(R0));
     // Check if the allocation fits into the remaining space.
     // R0: potential new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: potential next object start.
     __ LoadImmediate(IP, heap->EndAddress());
     __ ldr(IP, Address(IP, 0));
-    __ cmp(R3, ShifterOperand(IP));
+    __ cmp(R3, Operand(IP));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, CS);  // Branch if unsigned higher or equal.
     }
 
     // Successfully allocated the object, now update top to point to
     // next object start and initialize the object.
     // R0: new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     __ str(R3, Address(R5, 0));
-    __ add(R0, R0, ShifterOperand(kHeapObjectTag));
+    __ add(R0, R0, Operand(kHeapObjectTag));
     __ UpdateAllocationStatsWithSize(context_class.id(), R2, R5);
 
     // Calculate the size tag.
     // R0: new object.
     // R1: number of context variables.
     // R2: object size.
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
     // If no size tag overflow, shift R2 left, else set R2 to zero.
-    __ mov(R2, ShifterOperand(R2, LSL, shift), LS);
-    __ mov(R2, ShifterOperand(0), HI);
+    __ mov(R2, Operand(R2, LSL, shift), LS);
+    __ mov(R2, Operand(0), HI);
 
     // Get the class index and insert it into the tags.
     // R2: size and bit tags.
     __ LoadImmediate(IP, RawObject::ClassIdTag::encode(context_class.id()));
-    __ orr(R2, R2, ShifterOperand(IP));
+    __ orr(R2, R2, Operand(IP));
     __ str(R2, FieldAddress(R0, Context::tags_offset()));
 
     // Setup up number of context variables field.
     // R0: new object.
     // R1: number of context variables as integer value (not object).
     __ str(R1, FieldAddress(R0, Context::num_variables_offset()));
 
     // Setup isolate field.
     // Load Isolate pointer from Context structure into R2.
     // R0: new object.
     // R1: number of context variables.
     __ ldr(R2, FieldAddress(CTX, Context::isolate_offset()));
     // R2: isolate, not an object.
     __ str(R2, FieldAddress(R0, Context::isolate_offset()));
 
     // Setup the parent field.
     // R0: new object.
     // R1: number of context variables.
     __ LoadImmediate(R2, reinterpret_cast<intptr_t>(Object::null()));
     __ str(R2, FieldAddress(R0, Context::parent_offset()));
 
     // Initialize the context variables.
     // R0: new object.
     // R1: number of context variables.
     // R2: raw null.
     Label loop;
     __ AddImmediate(R3, R0, Context::variable_offset(0) - kHeapObjectTag);
     __ Bind(&loop);
-    __ subs(R1, R1, ShifterOperand(1));
+    __ subs(R1, R1, Operand(1));
     __ str(R2, Address(R3, R1, LSL, 2), PL);  // Store if R1 positive or zero.
     __ b(&loop, NE);  // Loop if R1 not zero.
 
     // Done allocating and initializing the context.
     // R0: new object.
     __ Ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame as we are pushing some objects on the stack before
@@ skipping 21 matching lines @@
 void StubCode::GenerateUpdateStoreBufferStub(Assembler* assembler) {
   // Save values being destroyed.
   __ PushList((1 << R1) | (1 << R2) | (1 << R3));
 
   Label add_to_buffer;
   // Check whether this object has already been remembered. Skip adding to the
   // store buffer if the object is in the store buffer already.
   // Spilled: R1, R2, R3
   // R0: Address being stored
   __ ldr(R2, FieldAddress(R0, Object::tags_offset()));
-  __ tst(R2, ShifterOperand(1 << RawObject::kRememberedBit));
+  __ tst(R2, Operand(1 << RawObject::kRememberedBit));
   __ b(&add_to_buffer, EQ);
   __ PopList((1 << R1) | (1 << R2) | (1 << R3));
   __ Ret();
 
   __ Bind(&add_to_buffer);
-  __ orr(R2, R2, ShifterOperand(1 << RawObject::kRememberedBit));
+  __ orr(R2, R2, Operand(1 << RawObject::kRememberedBit));
   __ str(R2, FieldAddress(R0, Object::tags_offset()));
 
   // Load the isolate out of the context.
   // Spilled: R1, R2, R3.
   // R0: address being stored.
   __ ldr(R1, FieldAddress(CTX, Context::isolate_offset()));
 
   // Load the StoreBuffer block out of the isolate. Then load top_ out of the
   // StoreBufferBlock and add the address to the pointers_.
   // R1: isolate.
   __ ldr(R1, Address(R1, Isolate::store_buffer_offset()));
   __ ldr(R2, Address(R1, StoreBufferBlock::top_offset()));
-  __ add(R3, R1, ShifterOperand(R2, LSL, 2));
+  __ add(R3, R1, Operand(R2, LSL, 2));
   __ str(R0, Address(R3, StoreBufferBlock::pointers_offset()));
 
   // Increment top_ and check for overflow.
   // R2: top_.
   // R1: StoreBufferBlock.
   Label L;
-  __ add(R2, R2, ShifterOperand(1));
+  __ add(R2, R2, Operand(1));
   __ str(R2, Address(R1, StoreBufferBlock::top_offset()));
   __ CompareImmediate(R2, StoreBufferBlock::kSize);
   // Restore values.
   __ PopList((1 << R1) | (1 << R2) | (1 << R3));
   __ b(&L, EQ);
   __ Ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
@@ skipping 34 matching lines @@
     // R1: instantiated type arguments (if is_cls_parameterized).
     Heap* heap = Isolate::Current()->heap();
     __ LoadImmediate(R5, heap->TopAddress());
     __ ldr(R2, Address(R5, 0));
     __ AddImmediate(R3, R2, instance_size);
     // Check if the allocation fits into the remaining space.
     // R2: potential new object start.
     // R3: potential next object start.
     __ LoadImmediate(IP, heap->EndAddress());
     __ ldr(IP, Address(IP, 0));
-    __ cmp(R3, ShifterOperand(IP));
+    __ cmp(R3, Operand(IP));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
       __ b(&slow_case, CS);  // Unsigned higher or equal.
     }
     __ str(R3, Address(R5, 0));
     __ UpdateAllocationStats(cls.id(), R5);
 
     // R2: new object start.
     // R3: next object start.
@@ skipping 16 matching lines @@
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
       // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
       for (intptr_t current_offset = Instance::NextFieldOffset();
            current_offset < instance_size;
            current_offset += kWordSize) {
         __ StoreToOffset(kWord, R0, R2, current_offset);
       }
     } else {
-      __ add(R4, R2, ShifterOperand(Instance::NextFieldOffset()));
+      __ add(R4, R2, Operand(Instance::NextFieldOffset()));
       // Loop until the whole object is initialized.
       // R0: raw null.
       // R2: new object.
       // R3: next object start.
       // R4: next word to be initialized.
       // R1: new object type arguments (if is_cls_parameterized).
       Label init_loop;
       Label done;
       __ Bind(&init_loop);
-      __ cmp(R4, ShifterOperand(R3));
+      __ cmp(R4, Operand(R3));
       __ b(&done, CS);
       __ str(R0, Address(R4, 0));
       __ AddImmediate(R4, kWordSize);
       __ b(&init_loop);
       __ Bind(&done);
     }
     if (is_cls_parameterized) {
       // R1: new object type arguments.
       // Set the type arguments in the new object.
       __ StoreToOffset(kWord, R1, R2, cls.type_arguments_field_offset());
     }
     // Done allocating and initializing the instance.
     // R2: new object still missing its heap tag.
-    __ add(R0, R2, ShifterOperand(kHeapObjectTag));
+    __ add(R0, R2, Operand(kHeapObjectTag));
     // R0: new object.
     __ Ret();
 
     __ Bind(&slow_case);
   }
   // If is_cls_parameterized:
   // R1: new object type arguments.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame(true);  // Uses pool pointer to pass cls to runtime.
@@ skipping 23 matching lines @@
 // Input parameters:
 //  LR : return address.
 //  SP : address of last argument.
 //  R5: inline cache data object.
 //  R4: arguments descriptor array.
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   __ EnterStubFrame();
 
   // Load the receiver.
   __ ldr(R2, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
-  __ add(IP, FP, ShifterOperand(R2, LSL, 1));  // R2 is Smi.
+  __ add(IP, FP, Operand(R2, LSL, 1));  // R2 is Smi.
   __ ldr(R6, Address(IP, kParamEndSlotFromFp * kWordSize));
 
   // Push space for the return value.
   // Push the receiver.
   // Push IC data object.
   // Push arguments descriptor array.
   __ LoadImmediate(IP, reinterpret_cast<intptr_t>(Object::null()));
   __ PushList((1 << R4) | (1 << R5) | (1 << R6) | (1 << IP));
 
   // R2: Smi-tagged arguments array length.
@@ skipping 19 matching lines @@
     __ EnterStubFrame();
     __ PushList((1 << R5) | (1 << R6));  // Preserve.
     __ Push(ic_reg);  // Argument.
     __ Push(func_reg);  // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ Drop(2);  // Discard argument;
     __ PopList((1 << R5) | (1 << R6));  // Restore.
     __ LeaveStubFrame();
   }
   __ ldr(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
-  __ add(R7, R7, ShifterOperand(1));
+  __ add(R7, R7, Operand(1));
   __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
 // Loads function into 'temp_reg'.
 void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
                                              Register temp_reg) {
   Register ic_reg = R5;
   Register func_reg = temp_reg;
   ASSERT(temp_reg == R6);
   __ ldr(func_reg, FieldAddress(ic_reg, ICData::owner_offset()));
   __ ldr(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
-  __ add(R7, R7, ShifterOperand(1));
+  __ add(R7, R7, Operand(1));
   __ str(R7, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
 // Generate inline cache check for 'num_args'.
 //  LR: return address.
 //  R5: inline cache data object.
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(
     Assembler* assembler,
     intptr_t num_args,
     const RuntimeEntry& handle_ic_miss) {
   ASSERT(num_args > 0);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == num_args.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ ldr(R6, FieldAddress(R5, ICData::state_bits_offset()));
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
-    __ and_(R6, R6, ShifterOperand(ICData::NumArgsTestedMask()));
+    __ and_(R6, R6, Operand(ICData::NumArgsTestedMask()));
     __ CompareImmediate(R6, num_args);
     __ b(&ok, EQ);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   if (FLAG_enable_debugger) {
     // Check single stepping.
     Label not_stepping;
     __ ldr(R6, FieldAddress(CTX, Context::isolate_offset()));
     __ ldrb(R6, Address(R6, Isolate::single_step_offset()));
     __ CompareImmediate(R6, 0);
     __ b(&not_stepping, EQ);
     __ EnterStubFrame();
     __ Push(R5);  // Preserve IC data.
     __ CallRuntime(kSingleStepHandlerRuntimeEntry, 0);
     __ Pop(R5);
     __ LeaveStubFrame();
     __ Bind(&not_stepping);
   }
 
   // Load arguments descriptor into R4.
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
   // Preserve return address, since LR is needed for subroutine call.
-  __ mov(R8, ShifterOperand(LR));
+  __ mov(R8, Operand(LR));
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found, get_class_id_as_smi;
   // R5: IC data object (preserved).
   __ ldr(R6, FieldAddress(R5, ICData::ic_data_offset()));
   // R6: ic_data_array with check entries: classes and target functions.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
   // R6: points directly to the first ic data array element.
 
   // Get the receiver's class ID (first read number of arguments from
   // arguments descriptor array and then access the receiver from the stack).
   __ ldr(R7, FieldAddress(R4, ArgumentsDescriptor::count_offset()));
-  __ sub(R7, R7, ShifterOperand(Smi::RawValue(1)));
+  __ sub(R7, R7, Operand(Smi::RawValue(1)));
   __ ldr(R0, Address(SP, R7, LSL, 1));  // R7 (argument_count - 1) is smi.
   __ bl(&get_class_id_as_smi);
   // R7: argument_count - 1 (smi).
   // R0: receiver's class ID (smi).
   __ ldr(R1, Address(R6, 0));  // First class id (smi) to check.
   __ b(&test);
 
   __ Bind(&loop);
   for (int i = 0; i < num_args; i++) {
     if (i > 0) {
       // If not the first, load the next argument's class ID.
       __ AddImmediate(R0, R7, Smi::RawValue(-i));
       __ ldr(R0, Address(SP, R0, LSL, 1));
       __ bl(&get_class_id_as_smi);
       // R0: next argument class ID (smi).
       __ LoadFromOffset(kWord, R1, R6, i * kWordSize);
       // R1: next class ID to check (smi).
     }
-    __ cmp(R0, ShifterOperand(R1));  // Class id match?
+    __ cmp(R0, Operand(R1));  // Class id match?
     if (i < (num_args - 1)) {
       __ b(&update, NE);  // Continue.
     } else {
       // Last check, all checks before matched.
-      __ mov(LR, ShifterOperand(R8), EQ);  // Restore return address if found.
+      __ mov(LR, Operand(R8), EQ);  // Restore return address if found.
       __ b(&found, EQ);  // Break.
     }
   }
   __ Bind(&update);
   // Reload receiver class ID.  It has not been destroyed when num_args == 1.
   if (num_args > 1) {
     __ ldr(R0, Address(SP, R7, LSL, 1));
     __ bl(&get_class_id_as_smi);
   }
 
   const intptr_t entry_size = ICData::TestEntryLengthFor(num_args) * kWordSize;
   __ AddImmediate(R6, entry_size);  // Next entry.
   __ ldr(R1, Address(R6, 0));  // Next class ID.
 
   __ Bind(&test);
   __ CompareImmediate(R1, Smi::RawValue(kIllegalCid));  // Done?
   __ b(&loop, NE);
 
   // IC miss.
   // Restore return address.
-  __ mov(LR, ShifterOperand(R8));
+  __ mov(LR, Operand(R8));
 
   // Compute address of arguments.
   // R7: argument_count - 1 (smi).
-  __ add(R7, SP, ShifterOperand(R7, LSL, 1));  // R7 is Smi.
+  __ add(R7, SP, Operand(R7, LSL, 1));  // R7 is Smi.
   // R7: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(R0, reinterpret_cast<intptr_t>(Object::null()));
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
   __ PushList((1 << R0) | (1 << R4) | (1 << R5));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
@@ skipping 11 matching lines @@
   __ LeaveStubFrame();
   Label call_target_function;
   __ b(&call_target_function);
 
   __ Bind(&found);
   // R6: pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ LoadFromOffset(kWord, R0, R6, target_offset);
   __ LoadFromOffset(kWord, R1, R6, count_offset);
-  __ adds(R1, R1, ShifterOperand(Smi::RawValue(1)));
+  __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ StoreToOffset(kWord, R1, R6, count_offset);
   __ b(&call_target_function, VC);  // No overflow.
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue));
   __ StoreToOffset(kWord, R1, R6, count_offset);
 
   __ Bind(&call_target_function);
   // R0: target function.
   __ ldr(R2, FieldAddress(R0, Function::code_offset()));
   __ ldr(R2, FieldAddress(R2, Code::instructions_offset()));
   __ AddImmediate(R2, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R2);
 
   // Instance in R0, return its class-id in R0 as Smi.
   __ Bind(&get_class_id_as_smi);
 
   // Test if Smi -> load Smi class for comparison.
-  __ tst(R0, ShifterOperand(kSmiTagMask));
-  __ mov(R0, ShifterOperand(Smi::RawValue(kSmiCid)), EQ);
+  __ tst(R0, Operand(kSmiTagMask));
+  __ mov(R0, Operand(Smi::RawValue(kSmiCid)), EQ);
   __ bx(LR, EQ);
   __ LoadClassId(R0, R0);
   __ SmiTag(R0);
   __ bx(LR);
 }
 
 
 // Use inline cache data array to invoke the target or continue in inline
 // cache miss handler. Stub for 1-argument check (receiver class).
 //  LR: return address.
@@ skipping 59 matching lines @@
 // the target function and the call count.
 // R5: ICData
 void StubCode::GenerateZeroArgsUnoptimizedStaticCallStub(Assembler* assembler) {
   GenerateUsageCounterIncrement(assembler, R6);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == 0.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ ldr(R6, FieldAddress(R5, ICData::state_bits_offset()));
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
-    __ and_(R6, R6, ShifterOperand(ICData::NumArgsTestedMask()));
+    __ and_(R6, R6, Operand(ICData::NumArgsTestedMask()));
     __ CompareImmediate(R6, 0);
     __ b(&ok, EQ);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   if (FLAG_enable_debugger) {
     // Check single stepping.
     Label not_stepping;
@@ skipping 13 matching lines @@
   __ ldr(R6, FieldAddress(R5, ICData::ic_data_offset()));
   // R6: ic_data_array with entries: target functions and count.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
   // R6: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
 
   // Increment count for this call.
   Label increment_done;
   __ LoadFromOffset(kWord, R1, R6, count_offset);
-  __ adds(R1, R1, ShifterOperand(Smi::RawValue(1)));
+  __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ StoreToOffset(kWord, R1, R6, count_offset);
   __ b(&increment_done, VC);  // No overflow.
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue));
   __ StoreToOffset(kWord, R1, R6, count_offset);
   __ Bind(&increment_done);
 
   // Load arguments descriptor into R4.
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
 
   // Get function and call it, if possible.
@@ skipping 78 matching lines @@
   if (n > 1) {
     // Get instance type arguments.
     __ LoadClass(R3, R0, R4);
     // Compute instance type arguments into R4.
     Label has_no_type_arguments;
     __ LoadImmediate(R4, reinterpret_cast<intptr_t>(Object::null()));
     __ ldr(R5, FieldAddress(R3,
         Class::type_arguments_field_offset_in_words_offset()));
     __ CompareImmediate(R5, Class::kNoTypeArguments);
     __ b(&has_no_type_arguments, EQ);
-    __ add(R5, R0, ShifterOperand(R5, LSL, 2));
+    __ add(R5, R0, Operand(R5, LSL, 2));
     __ ldr(R4, FieldAddress(R5, 0));
     __ Bind(&has_no_type_arguments);
   }
   __ LoadClassId(R3, R0);
   // R0: instance.
   // R1: instantiator type arguments or NULL.
   // R2: SubtypeTestCache.
   // R3: instance class id.
   // R4: instance type arguments (null if none), used only if n > 1.
   __ ldr(R2, FieldAddress(R2, SubtypeTestCache::cache_offset()));
   __ AddImmediate(R2, Array::data_offset() - kHeapObjectTag);
 
   Label loop, found, not_found, next_iteration;
   // R2: entry start.
   // R3: instance class id.
   // R4: instance type arguments.
   __ SmiTag(R3);
   __ Bind(&loop);
   __ ldr(R5, Address(R2, kWordSize * SubtypeTestCache::kInstanceClassId));
   __ CompareImmediate(R5, reinterpret_cast<intptr_t>(Object::null()));
   __ b(&not_found, EQ);
-  __ cmp(R5, ShifterOperand(R3));
+  __ cmp(R5, Operand(R3));
   if (n == 1) {
     __ b(&found, EQ);
   } else {
     __ b(&next_iteration, NE);
     __ ldr(R5,
            Address(R2, kWordSize * SubtypeTestCache::kInstanceTypeArguments));
-    __ cmp(R5, ShifterOperand(R4));
+    __ cmp(R5, Operand(R4));
     if (n == 2) {
       __ b(&found, EQ);
     } else {
       __ b(&next_iteration, NE);
       __ ldr(R5, Address(R2, kWordSize *
                              SubtypeTestCache::kInstantiatorTypeArguments));
-      __ cmp(R5, ShifterOperand(R1));
+      __ cmp(R5, Operand(R1));
       __ b(&found, EQ);
     }
   }
   __ Bind(&next_iteration);
   __ AddImmediate(R2, kWordSize * SubtypeTestCache::kTestEntryLength);
   __ b(&loop);
   // Fall through to not found.
   __ Bind(&not_found);
   __ LoadImmediate(R1, reinterpret_cast<intptr_t>(Object::null()));
   __ Ret();
@@ skipping 32 matching lines @@
 // R1: instantiator type arguments or NULL.
 // R2: cache array.
 // Result in R1: null -> not found, otherwise result (true or false).
 void StubCode::GenerateSubtype3TestCacheStub(Assembler* assembler) {
   GenerateSubtypeNTestCacheStub(assembler, 3);
 }
 
 
 // Return the current stack pointer address, used to do stack alignment checks.
 void StubCode::GenerateGetStackPointerStub(Assembler* assembler) {
-  __ mov(R0, ShifterOperand(SP));
+  __ mov(R0, Operand(SP));
   __ Ret();
 }
 
 
 // Jump to the exception or error handler.
 // LR: return address.
 // R0: program_counter.
 // R1: stack_pointer.
 // R2: frame_pointer.
 // R3: error object.
 // SP: address of stacktrace object.
 // Does not return.
 void StubCode::GenerateJumpToExceptionHandlerStub(Assembler* assembler) {
   ASSERT(kExceptionObjectReg == R0);
   ASSERT(kStackTraceObjectReg == R1);
-  __ mov(IP, ShifterOperand(R1));  // Stack pointer.
-  __ mov(LR, ShifterOperand(R0));  // Program counter.
-  __ mov(R0, ShifterOperand(R3));  // Exception object.
+  __ mov(IP, Operand(R1));  // Stack pointer.
+  __ mov(LR, Operand(R0));  // Program counter.
+  __ mov(R0, Operand(R3));  // Exception object.
   __ ldr(R1, Address(SP, 0));  // StackTrace object.
-  __ mov(FP, ShifterOperand(R2));  // Frame_pointer.
-  __ mov(SP, ShifterOperand(IP));  // Stack pointer.
+  __ mov(FP, Operand(R2));  // Frame_pointer.
+  __ mov(SP, Operand(IP));  // Stack pointer.
   __ bx(LR);  // Jump to the exception handler code.
 }
 
 
 // Calls to the runtime to optimize the given function.
 // R6: function to be reoptimized.
 // R4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ Push(R4);
@@ skipping 24 matching lines @@
 // Return Zero condition flag set if equal.
 // Note: A Mint cannot contain a value that would fit in Smi, a Bigint
 // cannot contain a value that fits in Mint or Smi.
 void StubCode::GenerateIdenticalWithNumberCheckStub(Assembler* assembler,
                                                     const Register left,
                                                     const Register right,
                                                     const Register temp,
                                                     const Register unused) {
   Label reference_compare, done, check_mint, check_bigint;
   // If any of the arguments is Smi do reference compare.
-  __ tst(left, ShifterOperand(kSmiTagMask));
+  __ tst(left, Operand(kSmiTagMask));
   __ b(&reference_compare, EQ);
-  __ tst(right, ShifterOperand(kSmiTagMask));
+  __ tst(right, Operand(kSmiTagMask));
   __ b(&reference_compare, EQ);
 
   // Value compare for two doubles.
   __ CompareClassId(left, kDoubleCid, temp);
   __ b(&check_mint, NE);
   __ CompareClassId(right, kDoubleCid, temp);
   __ b(&done, NE);
 
   // Double values bitwise compare.
   __ ldr(temp, FieldAddress(left, Double::value_offset() + 0 * kWordSize));
   __ ldr(IP, FieldAddress(right, Double::value_offset() + 0 * kWordSize));
-  __ cmp(temp, ShifterOperand(IP));
+  __ cmp(temp, Operand(IP));
   __ b(&done, NE);
   __ ldr(temp, FieldAddress(left, Double::value_offset() + 1 * kWordSize));
   __ ldr(IP, FieldAddress(right, Double::value_offset() + 1 * kWordSize));
-  __ cmp(temp, ShifterOperand(IP));
+  __ cmp(temp, Operand(IP));
   __ b(&done);
 
   __ Bind(&check_mint);
   __ CompareClassId(left, kMintCid, temp);
   __ b(&check_bigint, NE);
   __ CompareClassId(right, kMintCid, temp);
   __ b(&done, NE);
   __ ldr(temp, FieldAddress(left, Mint::value_offset() + 0 * kWordSize));
   __ ldr(IP, FieldAddress(right, Mint::value_offset() + 0 * kWordSize));
-  __ cmp(temp, ShifterOperand(IP));
+  __ cmp(temp, Operand(IP));
   __ b(&done, NE);
   __ ldr(temp, FieldAddress(left, Mint::value_offset() + 1 * kWordSize));
   __ ldr(IP, FieldAddress(right, Mint::value_offset() + 1 * kWordSize));
-  __ cmp(temp, ShifterOperand(IP));
+  __ cmp(temp, Operand(IP));
   __ b(&done);
 
   __ Bind(&check_bigint);
   __ CompareClassId(left, kBigintCid, temp);
   __ b(&reference_compare, NE);
   __ CompareClassId(right, kBigintCid, temp);
   __ b(&done, NE);
   __ EnterStubFrame();
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ stm(IA, SP,  (1 << R0) | (1 << R1));
   __ CallRuntime(kBigintCompareRuntimeEntry, 2);
   // Result in R0, 0 means equal.
   __ LeaveStubFrame();
-  __ cmp(R0, ShifterOperand(0));
+  __ cmp(R0, Operand(0));
   __ b(&done);
 
   __ Bind(&reference_compare);
-  __ cmp(left, ShifterOperand(right));
+  __ cmp(left, Operand(right));
   __ Bind(&done);
 }
 
 
 // Called only from unoptimized code. All relevant registers have been saved.
 // LR: return address.
 // SP + 4: left operand.
 // SP + 0: right operand.
 // Return Zero condition flag set if equal.
 void StubCode::GenerateUnoptimizedIdenticalWithNumberCheckStub(
@@ skipping 33 matching lines @@
   const Register right = R0;
   __ ldr(left, Address(SP, 1 * kWordSize));
   __ ldr(right, Address(SP, 0 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM