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 738 matching lines @@
     __ LoadObject(R0, loc.constant());
     __ str(R0, dest);
   } else if (loc.IsRegister()) {
     if (*push_emitted && (loc.reg() == R0)) {
       __ ldr(R0, Address(SP, 0));
       __ str(R0, dest);
     } else {
       __ str(loc.reg(), dest);
     }
   } else {
-    Address src = loc.ToStackSlotAddress();
+    const Address& src = Address::StackSlotAddress(loc);
     if (!src.Equals(dest)) {
       if (!*push_emitted) {
         __ Push(R0);
         *push_emitted = true;
       }
       __ ldr(R0, src);
       __ str(R0, dest);
     }
   }
 }
@@ skipping 874 matching lines @@
   assembler()->vcmpd(dleft, dright);
   assembler()->vmstat();
   assembler()->LoadObject(result, Bool::False());
   Label done;
   assembler()->b(&done, VS);  // NaN -> false.
   assembler()->LoadObject(result, Bool::True(), true_condition);
   assembler()->Bind(&done);
 }
 
 
 // Do not implement or use this function.

[regis, 2013/07/17 16:35:19]

The 4 functions below should also be part of a similar refactoring. You could
add a TODO here.

 FieldAddress FlowGraphCompiler::ElementAddressForIntIndex(intptr_t cid,
                                                           intptr_t index_scale,
                                                           Register array,
                                                           intptr_t index) {
   UNREACHABLE();
   return FieldAddress(array, index);
 }
 
 
 // Do not implement or use this function.
@@ skipping 31 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());
+      __ str(source.reg(), Address::StackSlotAddress(destination));
     }
   } else if (source.IsStackSlot()) {
     if (destination.IsRegister()) {
-      __ ldr(destination.reg(), source.ToStackSlotAddress());
+      __ ldr(destination.reg(), Address::StackSlotAddress(source));
     } else {
       ASSERT(destination.IsStackSlot());
-      MoveMemoryToMemory(destination.ToStackSlotAddress(),
-                         source.ToStackSlotAddress());
+      MoveMemoryToMemory(Address::StackSlotAddress(destination),
+                         Address::StackSlotAddress(source));
     }
   } 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()) {
         DRegister src = EvenDRegisterOf(source.fpu_reg());
-        __ vstrd(src, destination.ToStackSlotAddress());
+        __ vstrd(src, Address::StackSlotAddress(destination));
       } else {
         ASSERT(destination.IsQuadStackSlot());
         UNIMPLEMENTED();
       }
     }
   } else if (source.IsDoubleStackSlot()) {
     if (destination.IsFpuRegister()) {
       DRegister dst = EvenDRegisterOf(destination.fpu_reg());
-      __ vldrd(dst, source.ToStackSlotAddress());
+      __ vldrd(dst, Address::StackSlotAddress(source));
     } else {
       ASSERT(destination.IsDoubleStackSlot());
-      __ vldrd(DTMP, source.ToStackSlotAddress());
-      __ vstrd(DTMP, destination.ToStackSlotAddress());
+      __ vldrd(DTMP, Address::StackSlotAddress(source));
+      __ vstrd(DTMP, Address::StackSlotAddress(destination));
     }
   } 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());
+      StoreObject(Address::StackSlotAddress(destination), source.constant());
     }
   }
 
   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(), Address::StackSlotAddress(destination));
   } else if (source.IsStackSlot() && destination.IsRegister()) {
-    Exchange(destination.reg(), source.ToStackSlotAddress());
+    Exchange(destination.reg(), Address::StackSlotAddress(source));
   } else if (source.IsStackSlot() && destination.IsStackSlot()) {
-    Exchange(destination.ToStackSlotAddress(), source.ToStackSlotAddress());
+    Exchange(Address::StackSlotAddress(destination),
+             Address::StackSlotAddress(source));
   } 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();
+        ? Address::StackSlotAddress(destination)
+        : Address::StackSlotAddress(source);
 
     if (double_width) {
       __ vldrd(DTMP, slot_address);
       __ vstrd(reg, slot_address);
       __ 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 Address& source_slot_address = Address::StackSlotAddress(source);
+    const Address& destination_slot_address =
+        Address::StackSlotAddress(destination);
 
     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);
   } else if (source.IsQuadStackSlot() && destination.IsQuadStackSlot()) {
     UNIMPLEMENTED();
   } else {
@@ skipping 68 matching lines @@
   DRegister dreg = EvenDRegisterOf(reg);
   __ vldrd(dreg, Address(SP, kDoubleSize, Address::PostIndex));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM