Add AddImmediate(reg, int) to ARM64 assembler

runtime/vm/intrinsifier_arm64.cc

Index: runtime/vm/intrinsifier_arm64.cc
diff --git a/runtime/vm/intrinsifier_arm64.cc b/runtime/vm/intrinsifier_arm64.cc
index f580138edcdcd443d99289d6a7710b95e512e4ef..f400c02a1fb5b7e2fa1b797be44d72203a37e629 100644
--- a/runtime/vm/intrinsifier_arm64.cc
+++ b/runtime/vm/intrinsifier_arm64.cc
@@ -197,7 +197,7 @@ static int GetScaleFactor(intptr_t size) {
   __ 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()));                             \
@@ -219,7 +219,7 @@ static int GetScaleFactor(intptr_t size) {
   /* 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. */                              \
@@ -1856,19 +1856,19 @@ void GenerateSubstringMatchesSpecialization(Assembler* assembler,
   __ 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
@@ -1955,12 +1955,12 @@ void Intrinsifier::StringBaseCharAt(Assembler* assembler) {
   __ 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();
 
@@ -1968,12 +1968,12 @@ void Intrinsifier::StringBaseCharAt(Assembler* assembler) {
   __ 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();
 
@@ -2066,7 +2066,7 @@ static void TryAllocateOnebyteString(Assembler* assembler,
   // 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;
@@ -2090,7 +2090,7 @@ static void TryAllocateOnebyteString(Assembler* assembler,
   // 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.
@@ -2150,7 +2150,7 @@ void Intrinsifier::OneByteString_substringUnchecked(Assembler* assembler) {
   __ 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.
@@ -2171,11 +2171,11 @@ void Intrinsifier::OneByteString_substringUnchecked(Assembler* assembler) {
   __ 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);
@@ -2238,23 +2238,23 @@ static void StringEquality(Assembler* assembler, intptr_t string_cid) {
   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();
   }
@@ -2302,7 +2302,7 @@ void Intrinsifier::IntrinsifyRegExpExecuteMatch(Assembler* assembler,
   __ 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)));