Replaces Location::ToStackSlotAddress() with Location::ToStackSlotOffset()

runtime/vm/flow_graph_compiler_arm.cc

 // Copyright (c) 2013, 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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 717 matching lines @@
     }
     AllocateRegistersLocally(instr);
   } else if (instr->MayThrow()  &&
              (CurrentTryIndex() != CatchClauseNode::kInvalidTryIndex)) {
     // Optimized try-block: Sync locals to fixed stack locations.
     EmitTrySync(instr, CurrentTryIndex());
   }
 }
 
 
-// TODO(regis): Pass an offset instead of an Address to avoid addressing
-// mode restrictions and remove Operand::Equals() on IA32/X64 and
-// Address::Equals() on ARM/MIPS.
-void FlowGraphCompiler::EmitTrySyncMove(Address dest,
+void FlowGraphCompiler::EmitTrySyncMove(intptr_t dest_offset,
                                         Location loc,
                                         bool* push_emitted) {
   if (loc.IsConstant()) {
     if (!*push_emitted) {
       __ Push(R0);
       *push_emitted = true;
     }
     __ LoadObject(R0, loc.constant());
-    __ str(R0, dest);
+    __ StoreToOffset(kWord, R0, FP, dest_offset);
   } else if (loc.IsRegister()) {
     if (*push_emitted && (loc.reg() == R0)) {
       __ ldr(R0, Address(SP, 0));
-      __ str(R0, dest);
+      __ StoreToOffset(kWord, R0, FP, dest_offset);
     } else {
-      __ str(loc.reg(), dest);
+      __ StoreToOffset(kWord, loc.reg(), FP, dest_offset);
     }
   } else {
-    Address src = loc.ToStackSlotAddress();
-    if (!src.Equals(dest)) {
+    const intptr_t src_offset = loc.ToStackSlotOffset();
+    if (src_offset != dest_offset) {
       if (!*push_emitted) {
         __ Push(R0);
         *push_emitted = true;
       }
-      __ ldr(R0, src);
-      __ str(R0, dest);
+      __ LoadFromOffset(kWord, R0, FP, src_offset);
+      __ StoreToOffset(kWord, R0, FP, dest_offset);
     }
   }
 }
 
 
 void FlowGraphCompiler::EmitTrySync(Instruction* instr, intptr_t try_index) {
   ASSERT(is_optimizing());
   Environment* env = instr->env();
   CatchBlockEntryInstr* catch_block =
       flow_graph().graph_entry()->GetCatchEntry(try_index);
   const GrowableArray<Definition*>* idefs = catch_block->initial_definitions();
   // Parameters.
   intptr_t i = 0;
   bool push_emitted = false;
   const intptr_t num_non_copied_params = flow_graph().num_non_copied_params();
   const intptr_t param_base =
       kParamEndSlotFromFp + num_non_copied_params;
   for (; i < num_non_copied_params; ++i) {
     if ((*idefs)[i]->IsConstant()) continue;  // Common constants
     Location loc = env->LocationAt(i);
-    Address dest(FP, (param_base - i) * kWordSize);
-    EmitTrySyncMove(dest, loc, &push_emitted);
+    EmitTrySyncMove((param_base - i) * kWordSize, loc, &push_emitted);
   }
 
   // Process locals. Skip exception_var and stacktrace_var.
   CatchEntryInstr* catch_entry = catch_block->next()->AsCatchEntry();
   intptr_t local_base = kFirstLocalSlotFromFp + num_non_copied_params;
   intptr_t ex_idx = local_base - catch_entry->exception_var().index();
   intptr_t st_idx = local_base - catch_entry->stacktrace_var().index();
   for (; i < flow_graph().variable_count(); ++i) {
     if (i == ex_idx || i == st_idx) continue;
     if ((*idefs)[i]->IsConstant()) continue;
     Location loc = env->LocationAt(i);
-    Address dest(FP, (local_base - i) * kWordSize);
-    EmitTrySyncMove(dest, loc, &push_emitted);
+    EmitTrySyncMove((local_base - i) * kWordSize, loc, &push_emitted);
     // Update safepoint bitmap to indicate that the target location
     // now contains a pointer.
     instr->locs()->stack_bitmap()->Set(i - num_non_copied_params, true);
   }
   if (push_emitted) {
     __ Pop(R0);
   }
 }
 
 
@@ skipping 884 matching lines @@
 void ParallelMoveResolver::EmitMove(int index) {
   MoveOperands* move = moves_[index];
   const Location source = move->src();
   const Location destination = move->dest();
 
   if (source.IsRegister()) {
     if (destination.IsRegister()) {
       __ mov(destination.reg(), ShifterOperand(source.reg()));
     } else {
       ASSERT(destination.IsStackSlot());
-      __ str(source.reg(), destination.ToStackSlotAddress());
+      const intptr_t dest_offset = destination.ToStackSlotOffset();
+      __ StoreToOffset(kWord, source.reg(), FP, dest_offset);
     }
   } else if (source.IsStackSlot()) {
     if (destination.IsRegister()) {
-      __ ldr(destination.reg(), source.ToStackSlotAddress());
+      const intptr_t source_offset = source.ToStackSlotOffset();
+      __ LoadFromOffset(kWord, destination.reg(), FP, source_offset);
     } else {
       ASSERT(destination.IsStackSlot());
-      MoveMemoryToMemory(destination.ToStackSlotAddress(),
-                         source.ToStackSlotAddress());
+      const intptr_t source_offset = source.ToStackSlotOffset();
+      const intptr_t dest_offset = destination.ToStackSlotOffset();
+      __ LoadFromOffset(kWord, TMP, FP, source_offset);
+      __ StoreToOffset(kWord, TMP, FP, dest_offset);
     }
   } else if (source.IsFpuRegister()) {
     if (destination.IsFpuRegister()) {
       DRegister dst = EvenDRegisterOf(destination.fpu_reg());
       DRegister src = EvenDRegisterOf(source.fpu_reg());
       __ vmovd(dst, src);
     } else {
       if (destination.IsDoubleStackSlot()) {
+        const intptr_t dest_offset = destination.ToStackSlotOffset();
         DRegister src = EvenDRegisterOf(source.fpu_reg());
-        __ vstrd(src, destination.ToStackSlotAddress());
+        __ StoreDToOffset(src, FP, dest_offset);
       } else {
         ASSERT(destination.IsQuadStackSlot());
         UNIMPLEMENTED();
       }
     }
   } else if (source.IsDoubleStackSlot()) {
     if (destination.IsFpuRegister()) {
+      const intptr_t dest_offset = source.ToStackSlotOffset();
       DRegister dst = EvenDRegisterOf(destination.fpu_reg());
-      __ vldrd(dst, source.ToStackSlotAddress());
+      __ LoadDFromOffset(dst, FP, dest_offset);
     } else {
       ASSERT(destination.IsDoubleStackSlot());
-      __ vldrd(DTMP, source.ToStackSlotAddress());
-      __ vstrd(DTMP, destination.ToStackSlotAddress());
+      const intptr_t source_offset = source.ToStackSlotOffset();
+      const intptr_t dest_offset = destination.ToStackSlotOffset();
+      __ LoadDFromOffset(DTMP, FP, source_offset);
+      __ StoreDToOffset(DTMP, FP, dest_offset);
     }
   } else if (source.IsQuadStackSlot()) {
     UNIMPLEMENTED();
   } else {
     ASSERT(source.IsConstant());
     if (destination.IsRegister()) {
       const Object& constant = source.constant();
       __ LoadObject(destination.reg(), constant);
     } else {
       ASSERT(destination.IsStackSlot());
-      StoreObject(destination.ToStackSlotAddress(), source.constant());
+      const intptr_t dest_offset = destination.ToStackSlotOffset();
+      __ LoadObject(TMP, source.constant());
+      __ StoreToOffset(kWord, TMP, FP, dest_offset);
     }
   }
 
   move->Eliminate();
 }
 
 
 void ParallelMoveResolver::EmitSwap(int index) {
   MoveOperands* move = moves_[index];
   const Location source = move->src();
   const Location destination = move->dest();
 
   if (source.IsRegister() && destination.IsRegister()) {
     ASSERT(source.reg() != IP);
     ASSERT(destination.reg() != IP);
     __ mov(IP, ShifterOperand(source.reg()));
     __ mov(source.reg(), ShifterOperand(destination.reg()));
     __ mov(destination.reg(), ShifterOperand(IP));
   } else if (source.IsRegister() && destination.IsStackSlot()) {
-    Exchange(source.reg(), destination.ToStackSlotAddress());
+    Exchange(source.reg(), destination.ToStackSlotOffset());
   } else if (source.IsStackSlot() && destination.IsRegister()) {
-    Exchange(destination.reg(), source.ToStackSlotAddress());
+    Exchange(destination.reg(), source.ToStackSlotOffset());
   } else if (source.IsStackSlot() && destination.IsStackSlot()) {
-    Exchange(destination.ToStackSlotAddress(), source.ToStackSlotAddress());
+    Exchange(source.ToStackSlotOffset(), destination.ToStackSlotOffset());
   } else if (source.IsFpuRegister() && destination.IsFpuRegister()) {
     DRegister dst = EvenDRegisterOf(destination.fpu_reg());
     DRegister src = EvenDRegisterOf(source.fpu_reg());
     __ vmovd(DTMP, src);
     __ vmovd(src, dst);
     __ vmovd(dst, DTMP);
   } else if (source.IsFpuRegister() || destination.IsFpuRegister()) {
     ASSERT(destination.IsDoubleStackSlot() ||
            destination.IsQuadStackSlot() ||
            source.IsDoubleStackSlot() ||
            source.IsQuadStackSlot());
     bool double_width = destination.IsDoubleStackSlot() ||
                         source.IsDoubleStackSlot();
     QRegister qreg = source.IsFpuRegister() ? source.fpu_reg()
                                             : destination.fpu_reg();
     DRegister reg = EvenDRegisterOf(qreg);
-    const Address& slot_address = source.IsFpuRegister()
-        ? destination.ToStackSlotAddress()
-        : source.ToStackSlotAddress();
+    const intptr_t slot_offset = source.IsFpuRegister()
+        ? destination.ToStackSlotOffset()
+        : source.ToStackSlotOffset();
 
     if (double_width) {
-      __ vldrd(DTMP, slot_address);
-      __ vstrd(reg, slot_address);
+      __ LoadDFromOffset(DTMP, FP, slot_offset);
+      __ StoreDToOffset(reg, FP, slot_offset);
       __ vmovd(reg, DTMP);
     } else {
       UNIMPLEMENTED();
     }
   } else if (source.IsDoubleStackSlot() && destination.IsDoubleStackSlot()) {
-    const Address& source_slot_address = source.ToStackSlotAddress();
-    const Address& destination_slot_address = destination.ToStackSlotAddress();
+    const intptr_t source_offset = source.ToStackSlotOffset();
+    const intptr_t dest_offset = destination.ToStackSlotOffset();
 
     ScratchFpuRegisterScope ensure_scratch(this, QTMP);
     DRegister scratch = EvenDRegisterOf(ensure_scratch.reg());
-    __ vldrd(DTMP, source_slot_address);
-    __ vldrd(scratch, destination_slot_address);
-    __ vstrd(DTMP, destination_slot_address);
-    __ vstrd(scratch, source_slot_address);
+    __ LoadDFromOffset(DTMP, FP, source_offset);
+    __ LoadDFromOffset(scratch, FP, dest_offset);
+    __ StoreDToOffset(DTMP, FP, dest_offset);
+    __ StoreDToOffset(scratch, FP, source_offset);
   } else if (source.IsQuadStackSlot() && destination.IsQuadStackSlot()) {
     UNIMPLEMENTED();
   } else {
     UNREACHABLE();
   }
 
   // The swap of source and destination has executed a move from source to
   // destination.
   move->Eliminate();
 
@@ skipping 17 matching lines @@
   __ str(IP, dst);
 }
 
 
 void ParallelMoveResolver::StoreObject(const Address& dst, const Object& obj) {
   __ LoadObject(IP, obj);
   __ str(IP, dst);
 }
 
 
+// Do not call or implement this function. Instead, use the form below that
+// uses an offset from the frame pointer instead of an Address.
 void ParallelMoveResolver::Exchange(Register reg, const Address& mem) {
-  ASSERT(reg != IP);
-  __ mov(IP, ShifterOperand(reg));
-  __ ldr(reg, mem);
-  __ str(IP, mem);
+  UNREACHABLE();
 }
 
 
+// Do not call or implement this function. Instead, use the form below that
+// uses offsets from the frame pointer instead of Addresses.
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
-  ScratchRegisterScope ensure_scratch(this, IP);
-  __ ldr(ensure_scratch.reg(), mem1);
-  __ ldr(IP, mem2);
-  __ str(ensure_scratch.reg(), mem2);
-  __ str(IP, mem1);
+  UNREACHABLE();
 }
 
 
+void ParallelMoveResolver::Exchange(Register reg, intptr_t stack_offset) {
+  __ mov(TMP, ShifterOperand(reg));
+  __ LoadFromOffset(kWord, reg, FP, stack_offset);
+  __ StoreToOffset(kWord, TMP, FP, stack_offset);
+}
+
+
+void ParallelMoveResolver::Exchange(intptr_t stack_offset1,
+                                    intptr_t stack_offset2) {
+  ScratchRegisterScope ensure_scratch(this, IP);
+  __ LoadFromOffset(kWord, ensure_scratch.reg(), FP, stack_offset1);
+  __ LoadFromOffset(kWord, TMP, FP, stack_offset2);
+  __ StoreToOffset(kWord, ensure_scratch.reg(), FP, stack_offset2);
+  __ StoreToOffset(kWord, TMP, FP, stack_offset1);
+}
+
+
 void ParallelMoveResolver::SpillScratch(Register reg) {
   __ Push(reg);
 }
 
 
 void ParallelMoveResolver::RestoreScratch(Register reg) {
   __ Pop(reg);
 }
 
 
 void ParallelMoveResolver::SpillFpuScratch(FpuRegister reg) {
   DRegister dreg = EvenDRegisterOf(reg);
   __ vstrd(dreg, Address(SP, -kDoubleSize, Address::PreIndex));
 }
 
 
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   DRegister dreg = EvenDRegisterOf(reg);
   __ vldrd(dreg, Address(SP, kDoubleSize, Address::PostIndex));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM