Add AddImmediate(reg, int) to ARM64 assembler

runtime/vm/assembler_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"  // NOLINT
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/longjump.h"
@@ skipping 1017 matching lines @@
   // Finally, tag the result.
   SmiTag(result);
 }
 
 
 // Frame entry and exit.
 void Assembler::ReserveAlignedFrameSpace(intptr_t frame_space) {
   // Reserve space for arguments and align frame before entering
   // the C++ world.
   if (frame_space != 0) {
-    AddImmediate(SP, SP, -frame_space);
+    AddImmediate(SP, -frame_space);
   }
   if (OS::ActivationFrameAlignment() > 1) {
     andi(SP, SP, Immediate(~(OS::ActivationFrameAlignment() - 1)));
   }
 }
 
 
 void Assembler::RestoreCodePointer() {
   ldr(CODE_REG, Address(FP, kPcMarkerSlotFromFp * kWordSize));
   CheckCodePointer();
@@ skipping 77 matching lines @@
   // Load the pool pointer.
   if (new_pp == kNoRegister) {
     LoadPoolPointer();
   } else {
     mov(PP, new_pp);
     set_constant_pool_allowed(true);
   }
 
   // Reserve space.
   if (frame_size > 0) {
-    AddImmediate(SP, SP, -frame_size);
+    AddImmediate(SP, -frame_size);
   }
 }
 
 
 // On entry to a function compiled for OSR, the caller's frame pointer, the
 // stack locals, and any copied parameters are already in place.  The frame
 // pointer is already set up.  The PC marker is not correct for the
 // optimized function and there may be extra space for spill slots to
 // allocate. We must also set up the pool pointer for the function.
 void Assembler::EnterOsrFrame(intptr_t extra_size, Register new_pp) {
   ASSERT(!constant_pool_allowed());
   Comment("EnterOsrFrame");
   RestoreCodePointer();
   LoadPoolPointer();
 
   if (extra_size > 0) {
-    AddImmediate(SP, SP, -extra_size);
+    AddImmediate(SP, -extra_size);
   }
 }
 
 
 void Assembler::LeaveDartFrame(RestorePP restore_pp) {
   if (restore_pp == kRestoreCallerPP) {
     set_constant_pool_allowed(false);
     // Restore and untag PP.
     LoadFromOffset(PP, FP, kSavedCallerPpSlotFromFp * kWordSize);
     sub(PP, PP, Operand(kHeapObjectTag));
@@ skipping 111 matching lines @@
 #ifndef PRODUCT
 void Assembler::MaybeTraceAllocation(intptr_t cid,
                                      Register temp_reg,
                                      Label* trace) {
   ASSERT(cid > 0);
   intptr_t state_offset = ClassTable::StateOffsetFor(cid);
   LoadIsolate(temp_reg);
   intptr_t table_offset =
       Isolate::class_table_offset() + ClassTable::TableOffsetFor(cid);
   ldr(temp_reg, Address(temp_reg, table_offset));
-  AddImmediate(temp_reg, temp_reg, state_offset);
+  AddImmediate(temp_reg, state_offset);
   ldr(temp_reg, Address(temp_reg, 0));
   tsti(temp_reg, Immediate(ClassHeapStats::TraceAllocationMask()));
   b(trace, NE);
 }
 
 
 void Assembler::UpdateAllocationStats(intptr_t cid, Heap::Space space) {
   ASSERT(cid > 0);
   intptr_t counter_offset =
       ClassTable::CounterOffsetFor(cid, space == Heap::kNew);
   LoadIsolate(TMP2);
   intptr_t table_offset =
       Isolate::class_table_offset() + ClassTable::TableOffsetFor(cid);
   ldr(TMP, Address(TMP2, table_offset));
   AddImmediate(TMP2, TMP, counter_offset);
   ldr(TMP, Address(TMP2, 0));
-  AddImmediate(TMP, TMP, 1);
+  AddImmediate(TMP, 1);
   str(TMP, Address(TMP2, 0));
 }
 
 
 void Assembler::UpdateAllocationStatsWithSize(intptr_t cid,
                                               Register size_reg,
                                               Heap::Space space) {
   ASSERT(cid > 0);
   const uword class_offset = ClassTable::ClassOffsetFor(cid);
   const uword count_field_offset =
       (space == Heap::kNew)
           ? ClassHeapStats::allocated_since_gc_new_space_offset()
           : ClassHeapStats::allocated_since_gc_old_space_offset();
   const uword size_field_offset =
       (space == Heap::kNew)
           ? ClassHeapStats::allocated_size_since_gc_new_space_offset()
           : ClassHeapStats::allocated_size_since_gc_old_space_offset();
   LoadIsolate(TMP2);
   intptr_t table_offset =
       Isolate::class_table_offset() + ClassTable::TableOffsetFor(cid);
   ldr(TMP, Address(TMP2, table_offset));
   AddImmediate(TMP2, TMP, class_offset);
   ldr(TMP, Address(TMP2, count_field_offset));
-  AddImmediate(TMP, TMP, 1);
+  AddImmediate(TMP, 1);
   str(TMP, Address(TMP2, count_field_offset));
   ldr(TMP, Address(TMP2, size_field_offset));
   add(TMP, TMP, Operand(size_reg));
   str(TMP, Address(TMP2, size_field_offset));
 }
 #endif  // !PRODUCT
 
 
 void Assembler::TryAllocate(const Class& cls,
                             Label* failure,
@@ skipping 16 matching lines @@
     ldr(TMP, Address(temp_reg, Heap::EndOffset(space)));
     CompareRegisters(TMP, instance_reg);
     // fail if heap end unsigned less than or equal to instance_reg.
     b(failure, LS);
 
     // Successfully allocated the object, now update top to point to
     // next object start and store the class in the class field of object.
     str(instance_reg, Address(temp_reg, Heap::TopOffset(space)));
 
     ASSERT(instance_size >= kHeapObjectTag);
-    AddImmediate(instance_reg, instance_reg, -instance_size + kHeapObjectTag);
+    AddImmediate(instance_reg, -instance_size + kHeapObjectTag);
     NOT_IN_PRODUCT(UpdateAllocationStats(cls.id(), space));
 
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     LoadImmediate(TMP, tags);
     StoreFieldToOffset(TMP, instance_reg, Object::tags_offset());
   } else {
     b(failure);
@@ skipping 115 matching lines @@
       is_external ? 0 : (Instance::DataOffsetFor(cid) - kHeapObjectTag);
   if (shift == 0) {
     add(address, array, Operand(index));
   } else if (shift < 0) {
     ASSERT(shift == -1);
     add(address, array, Operand(index, ASR, 1));
   } else {
     add(address, array, Operand(index, LSL, shift));
   }
   if (offset != 0) {
-    AddImmediate(address, address, offset);
+    AddImmediate(address, offset);
   }
 }
 
 
 void Assembler::LoadUnaligned(Register dst,
                               Register addr,
                               Register tmp,
                               OperandSize sz) {
   ASSERT(dst != addr);
   ldr(dst, Address(addr, 0), kUnsignedByte);
@@ skipping 61 matching lines @@
   str(tmp, Address(addr, 7), kUnsignedByte);
   if (sz == kDoubleWord) {
     return;
   }
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64