A64: Implement support for stack slots in gap resolver

src/a64/lithium-gap-resolver-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 166 matching lines @@
   // We save in a register the source of that move and we remember its
   // destination. Then we mark this move as resolved so the cycle is
   // broken and we can perform the other moves.
   in_cycle_ = true;
   LOperand* source = moves_[index].source();
   saved_destination_ = moves_[index].destination();
 
   if (source->IsRegister()) {
     __ Mov(kSavedValue, cgen_->ToRegister(source));
   } else if (source->IsStackSlot()) {
-    UNIMPLEMENTED();
+    __ Ldr(kSavedValue, cgen_->ToMemOperand(source));
   } else if (source->IsDoubleRegister()) {
     // TODO(all): We should use a double register to store the value to avoid
     // the penalty of the mov across register banks. We are going to reserve
     // d31 to hold 0.0 value. We could clobber this register while breaking the
     // cycle and restore it after like we do with the root register.
     // LGapResolver::RestoreValue() will need to be updated as well when we'll
     // do that.
     __ Fmov(kSavedValue, cgen_->ToDoubleRegister(source));
   } else if (source->IsDoubleStackSlot()) {
-    UNIMPLEMENTED();
+    __ Ldr(kSavedValue, cgen_->ToMemOperand(source));
   } else {
     UNREACHABLE();
   }
 
   // Mark this move as resolved.
   // This move will be actually performed by moving the saved value to this
   // move's destination in LGapResolver::RestoreValue().
   moves_[index].Eliminate();
 }
 
 
 void LGapResolver::RestoreValue() {
   ASSERT(in_cycle_);
   ASSERT(saved_destination_ != NULL);
 
   if (saved_destination_->IsRegister()) {
     __ Mov(cgen_->ToRegister(saved_destination_), kSavedValue);
   } else if (saved_destination_->IsStackSlot()) {
-    UNIMPLEMENTED();
+    __ Str(kSavedValue, cgen_->ToMemOperand(saved_destination_));
   } else if (saved_destination_->IsDoubleRegister()) {
     __ Fmov(cgen_->ToDoubleRegister(saved_destination_), kSavedValue);
   } else if (saved_destination_->IsDoubleStackSlot()) {
-    UNIMPLEMENTED();
+    __ Str(kSavedValue, cgen_->ToMemOperand(saved_destination_));
   } else {
     UNREACHABLE();
   }
 
   in_cycle_ = false;
   saved_destination_ = NULL;
 }
 
 
 void LGapResolver::EmitMove(int index) {
@@ skipping 56 matching lines @@
     } else {
       ASSERT(destination->IsDoubleStackSlot());
       __ Str(src, cgen_->ToMemOperand(destination));
     }
 
   } else if (source->IsDoubleStackSlot()) {
     MemOperand src = cgen_->ToMemOperand(source);
     if (destination->IsDoubleRegister()) {
       __ Ldr(cgen_->ToDoubleRegister(destination), src);
     } else {
-      // TODO(all): double stack slot to double stack slot move.
-      UNIMPLEMENTED();
+      ASSERT(destination->IsDoubleStackSlot());

[Rodolph Perfetta (ARM), 2014/02/04 16:32:10]

How about reusing EmitStackSlotMove define below

+      DoubleRegister temp = crankshaft_fp_scratch;
+      __ Ldr(temp, src);
+      __ Str(temp, cgen_->ToMemOperand(destination));
     }
 
   } else {
     UNREACHABLE();
   }
 
   // The move has been emitted, we can eliminate it.
   moves_[index].Eliminate();
 }
 
 
 void LGapResolver::EmitStackSlotMove(int index) {
   // We need a temp register to perform a stack slot to stack slot move, and
   // the register must not be involved in breaking cycles.
 
   // Use the Crankshaft double scratch register as the temporary.
   DoubleRegister temp = crankshaft_fp_scratch;
 
   LOperand* src = moves_[index].source();
   LOperand* dst = moves_[index].destination();
 
   ASSERT(src->IsStackSlot());
   ASSERT(dst->IsStackSlot());
   __ Ldr(temp, cgen_->ToMemOperand(src));
   __ Str(temp, cgen_->ToMemOperand(dst));
 }
 
 } }  // namespace v8::internal