Add AddImmediate(reg, int) to ARM64 assembler

runtime/vm/intrinsifier_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"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 179 matching lines @@
   __ b(&fall_through, NE);                                                     \
   __ CompareRegisters(R2, ZR);                                                 \
   __ b(&fall_through, LT);                                                     \
   __ SmiUntag(R2);                                                             \
   /* Check for maximum allowed length. */                                      \
   /* R2: untagged array length. */                                             \
   __ CompareImmediate(R2, max_len);                                            \
   __ b(&fall_through, GT);                                                     \
   __ LslImmediate(R2, R2, scale_shift);                                        \
   const intptr_t fixed_size = sizeof(Raw##type_name) + kObjectAlignment - 1;   \
-  __ AddImmediate(R2, R2, fixed_size);                                         \
+  __ AddImmediate(R2, fixed_size);                                             \
   __ andi(R2, R2, Immediate(~(kObjectAlignment - 1)));                         \
   Heap::Space space = Heap::kNew;                                              \
   __ ldr(R3, Address(THR, Thread::heap_offset()));                             \
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));                             \
                                                                                \
   /* R2: allocation size. */                                                   \
   __ adds(R1, R0, Operand(R2));                                                \
   __ b(&fall_through, CS); /* Fail on unsigned overflow. */                    \
                                                                                \
   /* Check if the allocation fits into the remaining space. */                 \
   /* R0: potential new object start. */                                        \
   /* R1: potential next object start. */                                       \
   /* R2: allocation size. */                                                   \
   /* R3: heap. */                                                              \
   __ ldr(R6, Address(R3, Heap::EndOffset(space)));                             \
   __ cmp(R1, Operand(R6));                                                     \
   __ b(&fall_through, CS);                                                     \
                                                                                \
   /* Successfully allocated the object(s), now update top to point to */       \
   /* next object start and initialize the object. */                           \
   __ str(R1, Address(R3, Heap::TopOffset(space)));                             \
-  __ AddImmediate(R0, R0, kHeapObjectTag);                                     \
+  __ AddImmediate(R0, kHeapObjectTag);                                         \
   NOT_IN_PRODUCT(__ UpdateAllocationStatsWithSize(cid, R2, space));            \
   /* Initialize the tags. */                                                   \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
   /* R2: allocation size. */                                                   \
   {                                                                            \
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);                  \
     __ LslImmediate(R2, R2, RawObject::kSizeTagPos - kObjectAlignmentLog2);    \
     __ csel(R2, ZR, R2, HI);                                                   \
                                                                                \
@@ skipping 1616 matching lines @@
   // if (start < 0) return false;
   __ cmp(R1, Operand(0));
   __ b(return_false, LT);
 
   // if (start + other.length > this.length) return false;
   __ add(R3, R1, Operand(R9));
   __ cmp(R3, Operand(R8));
   __ b(return_false, GT);
 
   if (receiver_cid == kOneByteStringCid) {
-    __ AddImmediate(R0, R0, OneByteString::data_offset() - kHeapObjectTag);
+    __ AddImmediate(R0, OneByteString::data_offset() - kHeapObjectTag);
     __ add(R0, R0, Operand(R1));
   } else {
     ASSERT(receiver_cid == kTwoByteStringCid);
-    __ AddImmediate(R0, R0, TwoByteString::data_offset() - kHeapObjectTag);
+    __ AddImmediate(R0, TwoByteString::data_offset() - kHeapObjectTag);
     __ add(R0, R0, Operand(R1));
     __ add(R0, R0, Operand(R1));
   }
   if (other_cid == kOneByteStringCid) {
-    __ AddImmediate(R2, R2, OneByteString::data_offset() - kHeapObjectTag);
+    __ AddImmediate(R2, OneByteString::data_offset() - kHeapObjectTag);
   } else {
     ASSERT(other_cid == kTwoByteStringCid);
-    __ AddImmediate(R2, R2, TwoByteString::data_offset() - kHeapObjectTag);
+    __ AddImmediate(R2, TwoByteString::data_offset() - kHeapObjectTag);
   }
 
   // i = 0
   __ LoadImmediate(R3, 0);
 
   // do
   Label loop;
   __ Bind(&loop);
 
   // this.codeUnitAt(i + start)
@@ skipping 66 matching lines @@
   __ tsti(R1, Immediate(kSmiTagMask));
   __ b(&fall_through, NE);  // Index is not a Smi.
   // Range check.
   __ ldr(R2, FieldAddress(R0, String::length_offset()));
   __ cmp(R1, Operand(R2));
   __ b(&fall_through, CS);  // Runtime throws exception.
 
   __ CompareClassId(R0, kOneByteStringCid);
   __ b(&try_two_byte_string, NE);
   __ SmiUntag(R1);
-  __ AddImmediate(R0, R0, OneByteString::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R0, OneByteString::data_offset() - kHeapObjectTag);
   __ ldr(R1, Address(R0, R1), kUnsignedByte);
   __ CompareImmediate(R1, Symbols::kNumberOfOneCharCodeSymbols);
   __ b(&fall_through, GE);
   __ ldr(R0, Address(THR, Thread::predefined_symbols_address_offset()));
-  __ AddImmediate(R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ AddImmediate(R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ ldr(R0, Address(R0, R1, UXTX, Address::Scaled));
   __ ret();
 
   __ Bind(&try_two_byte_string);
   __ CompareClassId(R0, kTwoByteStringCid);
   __ b(&fall_through, NE);
   ASSERT(kSmiTagShift == 1);
-  __ AddImmediate(R0, R0, TwoByteString::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R0, TwoByteString::data_offset() - kHeapObjectTag);
   __ ldr(R1, Address(R0, R1), kUnsignedHalfword);
   __ CompareImmediate(R1, Symbols::kNumberOfOneCharCodeSymbols);
   __ b(&fall_through, GE);
   __ ldr(R0, Address(THR, Thread::predefined_symbols_address_offset()));
-  __ AddImmediate(R0, R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ AddImmediate(R0, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ ldr(R0, Address(R0, R1, UXTX, Address::Scaled));
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::StringBaseIsEmpty(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, String::length_offset()));
@@ skipping 72 matching lines @@
 static void TryAllocateOnebyteString(Assembler* assembler,
                                      Label* ok,
                                      Label* failure) {
   const Register length_reg = R2;
   Label fail;
   NOT_IN_PRODUCT(__ MaybeTraceAllocation(kOneByteStringCid, R0, failure));
   __ mov(R6, length_reg);  // Save the length register.
   // TODO(koda): Protect against negative length and overflow here.
   __ SmiUntag(length_reg);
   const intptr_t fixed_size = sizeof(RawString) + kObjectAlignment - 1;
-  __ AddImmediate(length_reg, length_reg, fixed_size);
+  __ AddImmediate(length_reg, fixed_size);
   __ andi(length_reg, length_reg, Immediate(~(kObjectAlignment - 1)));
 
   const intptr_t cid = kOneByteStringCid;
   Heap::Space space = Heap::kNew;
   __ ldr(R3, Address(THR, Thread::heap_offset()));
   __ ldr(R0, Address(R3, Heap::TopOffset(space)));
 
   // length_reg: allocation size.
   __ adds(R1, R0, Operand(length_reg));
   __ b(&fail, CS);  // Fail on unsigned overflow.
 
   // Check if the allocation fits into the remaining space.
   // R0: potential new object start.
   // R1: potential next object start.
   // R2: allocation size.
   // R3: heap.
   __ ldr(R7, Address(R3, Heap::EndOffset(space)));
   __ cmp(R1, Operand(R7));
   __ b(&fail, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ str(R1, Address(R3, Heap::TopOffset(space)));
-  __ AddImmediate(R0, R0, kHeapObjectTag);
+  __ AddImmediate(R0, kHeapObjectTag);
   NOT_IN_PRODUCT(__ UpdateAllocationStatsWithSize(cid, R2, space));
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R1: new object end address.
   // R2: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagPos - kObjectAlignmentLog2;
 
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
@@ skipping 39 matching lines @@
   __ sub(R2, R2, Operand(TMP));
   TryAllocateOnebyteString(assembler, &ok, &fall_through);
   __ Bind(&ok);
   // R0: new string as tagged pointer.
   // Copy string.
   __ ldr(R3, Address(SP, kStringOffset));
   __ ldr(R1, Address(SP, kStartIndexOffset));
   __ SmiUntag(R1);
   __ add(R3, R3, Operand(R1));
   // Calculate start address and untag (- 1).
-  __ AddImmediate(R3, R3, OneByteString::data_offset() - 1);
+  __ AddImmediate(R3, OneByteString::data_offset() - 1);
 
   // R3: Start address to copy from (untagged).
   // R1: Untagged start index.
   __ ldr(R2, Address(SP, kEndIndexOffset));
   __ SmiUntag(R2);
   __ sub(R2, R2, Operand(R1));
 
   // R3: Start address to copy from (untagged).
   // R2: Untagged number of bytes to copy.
   // R0: Tagged result string.
   // R6: Pointer into R3.
   // R7: Pointer into R0.
   // R1: Scratch register.
   Label loop, done;
   __ cmp(R2, Operand(0));
   __ b(&done, LE);
   __ mov(R6, R3);
   __ mov(R7, R0);
   __ Bind(&loop);
   __ ldr(R1, Address(R6), kUnsignedByte);
-  __ AddImmediate(R6, R6, 1);
+  __ AddImmediate(R6, 1);
   __ sub(R2, R2, Operand(1));
   __ cmp(R2, Operand(0));
   __ str(R1, FieldAddress(R7, OneByteString::data_offset()), kUnsignedByte);
-  __ AddImmediate(R7, R7, 1);
+  __ AddImmediate(R7, 1);
   __ b(&loop, GT);
 
   __ Bind(&done);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::OneByteStringSetAt(Assembler* assembler) {
   __ ldr(R2, Address(SP, 0 * kWordSize));  // Value.
@@ skipping 42 matching lines @@
   __ cmp(R2, Operand(R3));
   __ b(&is_false, NE);
 
   // Check contents, no fall-through possible.
   // TODO(zra): try out other sequences.
   ASSERT((string_cid == kOneByteStringCid) ||
          (string_cid == kTwoByteStringCid));
   const intptr_t offset = (string_cid == kOneByteStringCid)
                               ? OneByteString::data_offset()
                               : TwoByteString::data_offset();
-  __ AddImmediate(R0, R0, offset - kHeapObjectTag);
-  __ AddImmediate(R1, R1, offset - kHeapObjectTag);
+  __ AddImmediate(R0, offset - kHeapObjectTag);
+  __ AddImmediate(R1, offset - kHeapObjectTag);
   __ SmiUntag(R2);
   __ Bind(&loop);
-  __ AddImmediate(R2, R2, -1);
+  __ AddImmediate(R2, -1);
   __ CompareRegisters(R2, ZR);
   __ b(&is_true, LT);
   if (string_cid == kOneByteStringCid) {
     __ ldr(R3, Address(R0), kUnsignedByte);
     __ ldr(R4, Address(R1), kUnsignedByte);
-    __ AddImmediate(R0, R0, 1);
-    __ AddImmediate(R1, R1, 1);
+    __ AddImmediate(R0, 1);
+    __ AddImmediate(R1, 1);
   } else if (string_cid == kTwoByteStringCid) {
     __ ldr(R3, Address(R0), kUnsignedHalfword);
     __ ldr(R4, Address(R1), kUnsignedHalfword);
-    __ AddImmediate(R0, R0, 2);
-    __ AddImmediate(R1, R1, 2);
+    __ AddImmediate(R0, 2);
+    __ AddImmediate(R1, 2);
   } else {
     UNIMPLEMENTED();
   }
   __ cmp(R3, Operand(R4));
   __ b(&is_false, NE);
   __ b(&loop);
 
   __ Bind(&is_true);
   __ LoadObject(R0, Bool::True());
   __ ret();
@@ skipping 27 matching lines @@
   // Incoming registers:
   // R0: Function. (Will be reloaded with the specialized matcher function.)
   // R4: Arguments descriptor. (Will be preserved.)
   // R5: Unknown. (Must be GC safe on tail call.)
 
   // Load the specialized function pointer into R0. Leverage the fact the
   // string CIDs as well as stored function pointers are in sequence.
   __ ldr(R2, Address(SP, kRegExpParamOffset));
   __ ldr(R1, Address(SP, kStringParamOffset));
   __ LoadClassId(R1, R1);
-  __ AddImmediate(R1, R1, -kOneByteStringCid);
+  __ AddImmediate(R1, -kOneByteStringCid);
   __ add(R1, R2, Operand(R1, LSL, kWordSizeLog2));
   __ ldr(R0,
          FieldAddress(R1, RegExp::function_offset(kOneByteStringCid, sticky)));
 
   // Registers are now set up for the lazy compile stub. It expects the function
   // in R0, the argument descriptor in R4, and IC-Data in R5.
   __ eor(R5, R5, Operand(R5));
 
   // Tail-call the function.
   __ ldr(CODE_REG, FieldAddress(R0, Function::code_offset()));
@@ skipping 61 matching lines @@
 
 void Intrinsifier::SetAsyncThreadStackTrace(Assembler* assembler) {
   __ ldr(R0, Address(THR, Thread::async_stack_trace_offset()));
   __ LoadObject(R0, Object::null_object());
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64