Add AddImmediate(reg, int) to ARM64 assembler

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/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 69 matching lines @@
 
   // 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, R4);  // Set argc in NativeArguments.
 
   ASSERT(argv_offset == 2 * kWordSize);
   __ add(R2, ZR, Operand(R4, LSL, 3));
   __ add(R2, FP, Operand(R2));  // Compute argv.
   // Set argv in NativeArguments.
-  __ AddImmediate(R2, R2, kParamEndSlotFromFp * kWordSize);
+  __ AddImmediate(R2, kParamEndSlotFromFp * kWordSize);
 
   ASSERT(retval_offset == 3 * kWordSize);
   __ AddImmediate(R3, R2, kWordSize);
 
   __ StoreToOffset(R0, SP, thread_offset);
   __ StoreToOffset(R1, SP, argc_tag_offset);
   __ StoreToOffset(R2, SP, argv_offset);
   __ StoreToOffset(R3, SP, retval_offset);
   __ mov(R0, SP);  // Pass the pointer to the NativeArguments.
 
@@ skipping 309 matching lines @@
 static void PushArgumentsArray(Assembler* assembler) {
   // Allocate array to store arguments of caller.
   __ LoadObject(R1, Object::null_object());
   // R1: null element type for raw Array.
   // R2: smi-tagged argument count, may be zero.
   __ BranchLink(*StubCode::AllocateArray_entry());
   // 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, Operand(R2, LSL, 2));
-  __ AddImmediate(R1, R1, kParamEndSlotFromFp * kWordSize);
+  __ 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, loop_exit;
   __ CompareRegisters(R2, ZR);
   __ b(&loop_exit, LE);
   __ Bind(&loop);
   __ ldr(R7, Address(R1));
-  __ AddImmediate(R1, R1, -kWordSize);
-  __ AddImmediate(R3, R3, kWordSize);
+  __ AddImmediate(R1, -kWordSize);
+  __ AddImmediate(R3, kWordSize);
   __ AddImmediateSetFlags(R2, R2, -Smi::RawValue(1));
   __ str(R7, Address(R3, -kWordSize));
   __ b(&loop, GE);
   __ Bind(&loop_exit);
 }
 
 
 // Used by eager and lazy deoptimization. Preserve result in RAX if necessary.
 // This stub translates optimized frame into unoptimized frame. The optimized
 // frame can contain values in registers and on stack, the unoptimized
@@ skipping 348 matching lines @@
   __ AddImmediate(R1, R0, Array::data_offset() - kHeapObjectTag);
   // R1: iterator which initially points to the start of the variable
   // data area to be initialized.
   __ LoadObject(TMP, Object::null_object());
   Label loop, done;
   __ Bind(&loop);
   // TODO(cshapiro): StoreIntoObjectNoBarrier
   __ CompareRegisters(R1, R7);
   __ b(&done, CS);
   __ str(TMP, Address(R1));  // Store if unsigned lower.
-  __ AddImmediate(R1, R1, kWordSize);
+  __ AddImmediate(R1, kWordSize);
   __ b(&loop);  // Loop until R1 == R7.
   __ Bind(&done);
 
   // Done allocating and initializing the array.
   // R0: new object.
   // R2: array length as Smi (preserved for the caller.)
   __ ret();
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
@@ skipping 76 matching lines @@
 
   // Load arguments descriptor array into R4, which is passed to Dart code.
   __ LoadFromOffset(R4, R1, VMHandles::kOffsetOfRawPtrInHandle);
 
   // Load number of arguments into S5.
   __ LoadFieldFromOffset(R5, R4, ArgumentsDescriptor::count_offset());
   __ SmiUntag(R5);
 
   // Compute address of 'arguments array' data area into R2.
   __ LoadFromOffset(R2, R2, VMHandles::kOffsetOfRawPtrInHandle);
-  __ AddImmediate(R2, R2, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R2, Array::data_offset() - kHeapObjectTag);
 
   // Set up arguments for the Dart call.
   Label push_arguments;
   Label done_push_arguments;
   __ cmp(R5, Operand(0));
   __ b(&done_push_arguments, EQ);  // check if there are arguments.
   __ LoadImmediate(R1, 0);
   __ Bind(&push_arguments);
   __ ldr(R3, Address(R2));
   __ Push(R3);
@@ skipping 307 matching lines @@
       // 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);
       __ CompareRegisters(R4, R3);
       __ b(&done, CS);
       __ str(R0, Address(R4));
-      __ AddImmediate(R4, R4, kWordSize);
+      __ 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(R1, R2, cls.type_arguments_field_offset());
     }
     // Done allocating and initializing the instance.
     // R2: new object still missing its heap tag.
@@ skipping 88 matching lines @@
 void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
                                              Register temp_reg) {
   if (FLAG_optimization_counter_threshold >= 0) {
     Register ic_reg = R5;
     Register func_reg = temp_reg;
     ASSERT(temp_reg == R6);
     __ Comment("Increment function counter");
     __ LoadFieldFromOffset(func_reg, ic_reg, ICData::owner_offset());
     __ LoadFieldFromOffset(R7, func_reg, Function::usage_counter_offset(),
                            kWord);
-    __ AddImmediate(R7, R7, 1);
+    __ AddImmediate(R7, 1);
     __ StoreFieldToOffset(R7, func_reg, Function::usage_counter_offset(),
                           kWord);
   }
 }
 
 
 // Note: R5 must be preserved.
 // Attempt a quick Smi operation for known operations ('kind'). The ICData
 // must have been primed with a Smi/Smi check that will be used for counting
 // the invocations.
@@ skipping 25 matching lines @@
       __ csel(R0, R1, R0, NE);
       break;
     }
     default:
       UNIMPLEMENTED();
   }
 
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset());
   // R6: ic_data_array with check entries: classes and target functions.
-  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R6, Array::data_offset() - kHeapObjectTag);
 // R6: points directly to the first ic data array element.
 #if defined(DEBUG)
   // Check that first entry is for Smi/Smi.
   Label error, ok;
   const intptr_t imm_smi_cid = reinterpret_cast<intptr_t>(Smi::New(kSmiCid));
   __ ldr(R1, Address(R6, 0));
   __ CompareImmediate(R1, imm_smi_cid);
   __ b(&error, NE);
   __ ldr(R1, Address(R6, kWordSize));
   __ CompareImmediate(R1, imm_smi_cid);
@@ skipping 64 matching lines @@
   __ Bind(&not_smi_or_overflow);
 
   __ Comment("Extract ICData initial values and receiver cid");
   // Load arguments descriptor into R4.
   __ LoadFieldFromOffset(R4, R5, ICData::arguments_descriptor_offset());
   // Loop that checks if there is an IC data match.
   Label loop, found, miss;
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset());
   // R6: ic_data_array with check entries: classes and target functions.
-  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(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).
   __ LoadFieldFromOffset(R7, R4, ArgumentsDescriptor::count_offset());
   __ SmiUntag(R7);  // Untag so we can use the LSL 3 addressing mode.
   __ sub(R7, R7, Operand(1));
 
   // R0 <- [SP + (R7 << 3)]
   __ ldr(R0, Address(SP, R7, UXTX, Address::Scaled));
@@ skipping 20 matching lines @@
       __ b(&update, NE);  // Continue.
       __ LoadFromOffset(R2, R6, kWordSize);
       __ CompareRegisters(R1, R2);  // Class id match?
     }
     __ b(&found, EQ);  // Break.
 
     __ Bind(&update);
 
     const intptr_t entry_size =
         ICData::TestEntryLengthFor(num_args) * kWordSize;
-    __ AddImmediate(R6, R6, entry_size);  // Next entry.
+    __ AddImmediate(R6, entry_size);  // Next entry.
 
     __ CompareImmediate(R2, Smi::RawValue(kIllegalCid));  // Done?
     if (unroll == 0) {
       __ b(&loop, NE);
     } else {
       __ b(&miss, EQ);
     }
   }
 
   __ Bind(&miss);
@@ skipping 158 matching lines @@
     __ LoadIsolate(R6);
     __ LoadFromOffset(R6, R6, Isolate::single_step_offset(), kUnsignedByte);
     __ CompareImmediate(R6, 0);
     __ b(&stepping, NE);
     __ Bind(&done_stepping);
   }
 
   // R5: IC data object (preserved).
   __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset());
   // R6: ic_data_array with entries: target functions and count.
-  __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(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;
 
   if (FLAG_optimization_counter_threshold >= 0) {
     // Increment count for this call, ignore overflow.
     __ LoadFromOffset(R1, R6, count_offset);
     __ adds(R1, R1, Operand(Smi::RawValue(1)));
     __ StoreToOffset(R1, R6, count_offset);
   }
@@ skipping 123 matching lines @@
     __ Bind(&has_no_type_arguments);
   }
   __ LoadClassId(R6, R0);
   // R0: instance.
   // R1: instantiator type arguments (only if n == 4, can be raw_null).
   // R2: function type arguments (only if n == 4, can be raw_null).
   // R3: SubtypeTestCache.
   // R6: instance class id.
   // R4: instance type arguments (null if none), used only if n > 1.
   __ LoadFieldFromOffset(R3, R3, SubtypeTestCache::cache_offset());
-  __ AddImmediate(R3, R3, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R3, Array::data_offset() - kHeapObjectTag);
 
   Label loop, found, not_found, next_iteration;
   // R3: entry start.
   // R6: instance class id.
   // R4: instance type arguments (still null if closure).
   __ SmiTag(R6);
   __ CompareImmediate(R6, Smi::RawValue(kClosureCid));
   __ b(&loop, NE);
   __ LoadFieldFromOffset(R4, R0, Closure::function_type_arguments_offset());
   __ CompareObject(R4, Object::null_object());
@@ skipping 22 matching lines @@
           R5, R3, kWordSize * SubtypeTestCache::kInstantiatorTypeArguments);
       __ CompareRegisters(R5, R1);
       __ b(&next_iteration, NE);
       __ LoadFromOffset(R5, R3,
                         kWordSize * SubtypeTestCache::kFunctionTypeArguments);
       __ CompareRegisters(R5, R2);
       __ b(&found, EQ);
     }
   }
   __ Bind(&next_iteration);
-  __ AddImmediate(R3, R3, kWordSize * SubtypeTestCache::kTestEntryLength);
+  __ AddImmediate(R3, kWordSize * SubtypeTestCache::kTestEntryLength);
   __ b(&loop);
   // Fall through to not found.
   __ Bind(&not_found);
   __ LoadObject(R1, Object::null_object());
   __ ret();
 
   __ Bind(&found);
   __ LoadFromOffset(R1, R3, kWordSize * SubtypeTestCache::kTestResult);
   __ ret();
 }
@@ skipping 294 matching lines @@
   __ ldr(CODE_REG, FieldAddress(R0, Function::code_offset()));
   __ br(R1);
 
   // Probe failed, check if it is a miss.
   __ Bind(&probe_failed);
   ASSERT(kIllegalCid == 0);
   __ tst(R6, Operand(R6));
   __ b(&load_target, EQ);  // branch if miss.
 
   // Try next extry in the table.
-  __ AddImmediate(R3, R3, Smi::RawValue(1));
+  __ AddImmediate(R3, Smi::RawValue(1));
   __ b(&loop);
 
   // Load cid for the Smi case.
   __ Bind(&smi_case);
   __ LoadImmediate(R0, kSmiCid);
   __ b(&cid_loaded);
 }
 
 
 // Called from switchable IC calls.
 //  R0: receiver
 //  R5: ICData (preserved)
 // Passed to target:
 //  CODE_REG: target Code object
 //  R4: arguments descriptor
 void StubCode::GenerateICCallThroughFunctionStub(Assembler* assembler) {
   Label loop, found, miss;
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
   __ ldr(R8, FieldAddress(R5, ICData::ic_data_offset()));
-  __ AddImmediate(R8, R8, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R8, Array::data_offset() - kHeapObjectTag);
   // R8: first IC entry
   __ LoadTaggedClassIdMayBeSmi(R1, R0);
   // R1: receiver cid as Smi
 
   __ Bind(&loop);
   __ ldr(R2, Address(R8, 0));
   __ cmp(R1, Operand(R2));
   __ b(&found, EQ);
   __ CompareImmediate(R2, Smi::RawValue(kIllegalCid));
   __ b(&miss, EQ);
 
   const intptr_t entry_length = ICData::TestEntryLengthFor(1) * kWordSize;
-  __ AddImmediate(R8, R8, entry_length);  // Next entry.
+  __ AddImmediate(R8, entry_length);  // Next entry.
   __ b(&loop);
 
   __ Bind(&found);
   const intptr_t target_offset = ICData::TargetIndexFor(1) * kWordSize;
   __ ldr(R0, Address(R8, target_offset));
   __ ldr(R1, FieldAddress(R0, Function::entry_point_offset()));
   __ ldr(CODE_REG, FieldAddress(R0, Function::code_offset()));
   __ br(R1);
 
   __ Bind(&miss);
   __ LoadIsolate(R2);
   __ ldr(CODE_REG, Address(R2, Isolate::ic_miss_code_offset()));
   __ ldr(R1, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ br(R1);
 }
 
 
 void StubCode::GenerateICCallThroughCodeStub(Assembler* assembler) {
   Label loop, found, miss;
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
   __ ldr(R8, FieldAddress(R5, ICData::ic_data_offset()));
-  __ AddImmediate(R8, R8, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R8, Array::data_offset() - kHeapObjectTag);
   // R8: first IC entry
   __ LoadTaggedClassIdMayBeSmi(R1, R0);
   // R1: receiver cid as Smi
 
   __ Bind(&loop);
   __ ldr(R2, Address(R8, 0));
   __ cmp(R1, Operand(R2));
   __ b(&found, EQ);
   __ CompareImmediate(R2, Smi::RawValue(kIllegalCid));
   __ b(&miss, EQ);
 
   const intptr_t entry_length = ICData::TestEntryLengthFor(1) * kWordSize;
-  __ AddImmediate(R8, R8, entry_length);  // Next entry.
+  __ AddImmediate(R8, entry_length);  // Next entry.
   __ b(&loop);
 
   __ Bind(&found);
   const intptr_t code_offset = ICData::CodeIndexFor(1) * kWordSize;
   const intptr_t entry_offset = ICData::EntryPointIndexFor(1) * kWordSize;
   __ ldr(R1, Address(R8, entry_offset));
   __ ldr(CODE_REG, Address(R8, code_offset));
   __ br(R1);
 
   __ Bind(&miss);
@@ skipping 95 matching lines @@
 }
 
 
 void StubCode::GenerateAsynchronousGapMarkerStub(Assembler* assembler) {
   __ brk(0);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64