Expands the use of Immediate and Operand wrappers.

runtime/vm/stub_code_arm64.cc

 // Copyright (c) 2014, 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_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 658 matching lines @@
 // NOTE: R2 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in R0.
 void StubCode::GeneratePatchableAllocateArrayStub(Assembler* assembler,
     uword* entry_patch_offset, uword* patch_code_pc_offset) {
   *entry_patch_offset = assembler->CodeSize();
   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)).
   // Assert that length is a Smi.
-  __ tsti(R2, kSmiTagMask);
+  __ tsti(R2, Immediate(kSmiTagMask));
   if (FLAG_use_slow_path) {
     __ b(&slow_case);
   } else {
     __ b(&slow_case, NE);
   }
   __ cmp(R2, Operand(0));
   __ b(&slow_case, LT);
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
   const intptr_t cid = kArrayCid;
   Heap::Space space = heap->SpaceForAllocation(cid);
   const uword top_address = heap->TopAddress(space);
   __ LoadImmediate(R8, top_address, kNoPP);
   const uword end_address = heap->EndAddress(space);
   ASSERT(top_address < end_address);
   const uword top_offset = 0;
   const uword end_offset = end_address - top_address;
 
   // Calculate and align allocation size.
   // Load new object start and calculate next object start.
   // R1: array element type.
   // R2: array length as Smi.
   // R8: points to new space object.
   __ LoadFromOffset(R0, R8, top_offset, kNoPP);
   intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
   __ LoadImmediate(R3, fixed_size, kNoPP);
   __ add(R3, R3, Operand(R2, LSL, 2));  // R2 is Smi.
   ASSERT(kSmiTagShift == 1);
-  __ andi(R3, R3, ~(kObjectAlignment - 1));
+  __ andi(R3, R3, Immediate(~(kObjectAlignment - 1)));
   __ adds(R7, R3, Operand(R0));
   __ b(&slow_case, VS);
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
   // R1: array element type.
   // R2: array length as Smi.
   // R3: array size.
   // R7: potential next object start.
   // R8: points to new space object.
@@ skipping 272 matching lines @@
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
   if (FLAG_inline_alloc) {
     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, kNoPP);
     __ add(R2, R2, Operand(R1, LSL, 3));
     ASSERT(kSmiTagShift == 1);
-    __ andi(R2, R2, ~(kObjectAlignment - 1));
+    __ andi(R2, R2, Immediate(~(kObjectAlignment - 1)));
 
     // Now allocate the object.
     // R1: number of context variables.
     // R2: object size.
     const intptr_t cid = kContextCid;
     Heap::Space space = heap->SpaceForAllocation(cid);
     __ LoadImmediate(R5, heap->TopAddress(space), kNoPP);
     __ ldr(R0, Address(R5));
     __ add(R3, R2, Operand(R0));
     // Check if the allocation fits into the remaining space.
@@ skipping 97 matching lines @@
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
 // Helper stub to implement Assembler::StoreIntoObject.
 // Input parameters:
 //   R0: Address being stored
 void StubCode::GenerateUpdateStoreBufferStub(Assembler* assembler) {
   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.
   __ LoadFieldFromOffset(TMP, R0, Object::tags_offset(), kNoPP);
-  __ tsti(TMP, 1 << RawObject::kRememberedBit);
+  __ tsti(TMP, Immediate(1 << RawObject::kRememberedBit));
   __ b(&add_to_buffer, EQ);
   __ ret();
 
   __ Bind(&add_to_buffer);
   // Save values being destroyed.
   __ Push(R1);
   __ Push(R2);
   __ Push(R3);
 
-  __ orri(R2, TMP, 1 << RawObject::kRememberedBit);
+  __ orri(R2, TMP, Immediate(1 << RawObject::kRememberedBit));
   __ StoreFieldToOffset(R2, R0, Object::tags_offset(), kNoPP);
 
   // Load the isolate.
   // Spilled: R1, R2, R3.
   // R0: address being stored.
   __ LoadIsolate(R1, kNoPP);
 
   // Load the StoreBuffer block out of the isolate. Then load top_ out of the
   // StoreBufferBlock and add the address to the pointers_.
   // R1: isolate.
@@ skipping 245 matching lines @@
                           Token::Kind kind,
                           intptr_t num_args,
                           Label* not_smi_or_overflow) {
   if (FLAG_throw_on_javascript_int_overflow) {
     // The overflow check is more complex than implemented below.
     return;
   }
   __ ldr(R0, Address(SP, + 0 * kWordSize));  // Right.
   __ ldr(R1, Address(SP, + 1 * kWordSize));  // Left.
   __ orr(TMP, R0, Operand(R1));
-  __ tsti(TMP, kSmiTagMask);
+  __ tsti(TMP, Immediate(kSmiTagMask));
   __ b(not_smi_or_overflow, NE);
   switch (kind) {
     case Token::kADD: {
       __ adds(R0, R1, Operand(R0));  // Adds.
       __ b(not_smi_or_overflow, VS);  // Branch if overflow.
       break;
     }
     case Token::kSUB: {
       __ subs(R0, R1, Operand(R0));  // Subtract.
       __ b(not_smi_or_overflow, VS);  // Branch if overflow.
@@ skipping 56 matching lines @@
     const RuntimeEntry& handle_ic_miss,
     Token::Kind kind) {
   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'.
     __ LoadFromOffset(R6, R5, ICData::state_bits_offset() - kHeapObjectTag,
                       kNoPP, kUnsignedWord);
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
-    __ andi(R6, R6, ICData::NumArgsTestedMask());
+    __ andi(R6, R6, Immediate(ICData::NumArgsTestedMask()));
     __ CompareImmediate(R6, num_args, kNoPP);
     __ b(&ok, EQ);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   // Check single stepping.
   Label stepping, done_stepping;
   __ LoadIsolate(R6, kNoPP);
@@ skipping 211 matching lines @@
 
 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'.
     __ LoadFromOffset(R6, R5, ICData::state_bits_offset() - kHeapObjectTag,
                       kNoPP, kUnsignedWord);
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
-    __ andi(R6, R6, ICData::NumArgsTestedMask());
+    __ andi(R6, R6, Immediate(ICData::NumArgsTestedMask()));
     __ CompareImmediate(R6, 0, kNoPP);
     __ b(&ok, EQ);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
   // Check single stepping.
   Label stepping, done_stepping;
   __ LoadIsolate(R6, kNoPP);
@@ skipping 311 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 unused1,
                                                     const Register unused2) {
   Label reference_compare, done, check_mint, check_bigint;
   // If any of the arguments is Smi do reference compare.
-  __ tsti(left, kSmiTagMask);
+  __ tsti(left, Immediate(kSmiTagMask));
   __ b(&reference_compare, EQ);
-  __ tsti(right, kSmiTagMask);
+  __ tsti(right, Immediate(kSmiTagMask));
   __ b(&reference_compare, EQ);
 
   // Value compare for two doubles.
   __ CompareClassId(left, kDoubleCid, kNoPP);
   __ b(&check_mint, NE);
   __ CompareClassId(right, kDoubleCid, kNoPP);
   __ b(&done, NE);
 
   // Double values bitwise compare.
   __ LoadFieldFromOffset(left, left, Double::value_offset(), kNoPP);
@@ skipping 74 matching lines @@
   const Register right = R0;
   __ LoadFromOffset(left, SP, 1 * kWordSize, kNoPP);
   __ LoadFromOffset(right, SP, 0 * kWordSize, kNoPP);
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64