Add AddImmediate(reg, int) to ARM64 assembler

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 182 matching lines @@
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ LslImmediate(result, result, shift + kSmiTagSize);
   } else {
     __ sub(result, result, Operand(1));
     const int64_t val = Smi::RawValue(true_value) - Smi::RawValue(false_value);
     __ AndImmediate(result, result, val);
     if (false_value != 0) {
-      __ AddImmediate(result, result, Smi::RawValue(false_value));
+      __ AddImmediate(result, Smi::RawValue(false_value));
     }
   }
 }
 
 
 LocationSummary* ClosureCallInstr::MakeLocationSummary(Zone* zone,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new (zone)
@@ skipping 651 matching lines @@
 }
 
 
 void OneByteStringFromCharCodeInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   ASSERT(compiler->is_optimizing());
   const Register char_code = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
 
   __ ldr(result, Address(THR, Thread::predefined_symbols_address_offset()));
-  __ AddImmediate(result, result,
-                  Symbols::kNullCharCodeSymbolOffset * kWordSize);
+  __ AddImmediate(result, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ SmiUntag(TMP, char_code);  // Untag to use scaled address mode.
   __ ldr(result, Address(result, TMP, UXTX, Address::Scaled));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(zone, kNumInputs, Location::RequiresRegister(),
                                LocationSummary::kNoCall);
@@ skipping 1281 matching lines @@
       while (current_offset < array_size) {
         __ str(R6, Address(R8, current_offset));
         current_offset += kWordSize;
       }
     } else {
       Label end_loop, init_loop;
       __ Bind(&init_loop);
       __ CompareRegisters(R8, R3);
       __ b(&end_loop, CS);
       __ str(R6, Address(R8));
-      __ AddImmediate(R8, R8, kWordSize);
+      __ AddImmediate(R8, kWordSize);
       __ b(&init_loop);
       __ Bind(&end_loop);
     }
   }
   __ b(done);
 }
 
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register kLengthReg = R2;
@@ skipping 227 matching lines @@
     __ CompareObject(function_type_args_reg, Object::null_object());
     __ b(&type_arguments_instantiated, EQ);
     __ Bind(&non_null_type_args);
   }
 
   // Lookup cache before calling runtime.
   // TODO(regis): Consider moving this into a shared stub to reduce
   // generated code size.
   __ LoadObject(R3, type_arguments());
   __ LoadFieldFromOffset(R3, R3, TypeArguments::instantiations_offset());
-  __ AddImmediate(R3, R3, Array::data_offset() - kHeapObjectTag);
+  __ AddImmediate(R3, Array::data_offset() - kHeapObjectTag);
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, next, found, slow_case;
   __ Bind(&loop);
   __ LoadFromOffset(R2, R3, 0 * kWordSize);  // Cached instantiator type args.
   __ CompareRegisters(R2, instantiator_type_args_reg);
   __ b(&next, NE);
   __ LoadFromOffset(TMP, R3, 1 * kWordSize);  // Cached function type args.
   __ CompareRegisters(TMP, function_type_args_reg);
   __ b(&found, EQ);
   __ Bind(&next);
-  __ AddImmediate(R3, R3, StubCode::kInstantiationSizeInWords * kWordSize);
+  __ AddImmediate(R3, StubCode::kInstantiationSizeInWords * kWordSize);
   __ CompareImmediate(R2, Smi::RawValue(StubCode::kNoInstantiator));
   __ b(&loop, NE);
   __ b(&slow_case);
   __ Bind(&found);
   __ LoadFromOffset(result_reg, R3, 2 * kWordSize);  // Cached instantiated ta.
   __ b(&type_arguments_instantiated);
 
   __ Bind(&slow_case);
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
@@ skipping 3054 matching lines @@
   __ b(deopt, cond);
 }
 
 
 void CheckClassInstr::EmitBitTest(FlowGraphCompiler* compiler,
                                   intptr_t min,
                                   intptr_t max,
                                   intptr_t mask,
                                   Label* deopt) {
   Register biased_cid = locs()->temp(0).reg();
-  __ AddImmediate(biased_cid, biased_cid, -min);
+  __ AddImmediate(biased_cid, -min);
   __ CompareImmediate(biased_cid, max - min);
   __ b(deopt, HI);
 
   Register bit_reg = locs()->temp(1).reg();
   __ LoadImmediate(bit_reg, 1);
   __ lslv(bit_reg, bit_reg, biased_cid);
   __ TestImmediate(bit_reg, mask);
   __ b(deopt, EQ);
 }
 
 
 int CheckClassInstr::EmitCheckCid(FlowGraphCompiler* compiler,
                                   int bias,
                                   intptr_t cid_start,
                                   intptr_t cid_end,
                                   bool is_last,
                                   Label* is_ok,
                                   Label* deopt,
                                   bool use_near_jump) {
   Register biased_cid = locs()->temp(0).reg();
   Condition no_match, match;
   if (cid_start == cid_end) {
     __ CompareImmediate(biased_cid, cid_start - bias);
     no_match = NE;
     match = EQ;
   } else {
     // For class ID ranges use a subtract followed by an unsigned
     // comparison to check both ends of the ranges with one comparison.
-    __ AddImmediate(biased_cid, biased_cid, bias - cid_start);
+    __ AddImmediate(biased_cid, bias - cid_start);
     bias = cid_start;
     __ CompareImmediate(biased_cid, cid_end - cid_start);
     no_match = HI;  // Unsigned higher.
     match = LS;     // Unsigned lower or same.
   }
   if (is_last) {
     __ b(deopt, no_match);
   } else {
     __ b(is_ok, match);
   }
@@ skipping 374 matching lines @@
 
 void IndirectGotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register target_address_reg = locs()->temp_slot(0)->reg();
 
   // Load code entry point.
   const intptr_t entry_offset = __ CodeSize();
   if (Utils::IsInt(21, -entry_offset)) {
     __ adr(target_address_reg, Immediate(-entry_offset));
   } else {
     __ adr(target_address_reg, Immediate(0));
-    __ AddImmediate(target_address_reg, target_address_reg, -entry_offset);
+    __ AddImmediate(target_address_reg, -entry_offset);
   }
 
   // Add the offset.
   Register offset_reg = locs()->in(0).reg();
   Operand offset_opr = (offset()->definition()->representation() == kTagged)
                            ? Operand(offset_reg, ASR, kSmiTagSize)
                            : Operand(offset_reg);
   __ add(target_address_reg, target_address_reg, offset_opr);
 
   // Jump to the absolute address.
@@ skipping 143 matching lines @@
   compiler->GenerateRuntimeCall(TokenPosition::kNoSource, deopt_id(),
                                 kGrowRegExpStackRuntimeEntry, 1, locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64