ARM64: Regenerate instead of spilling and restoring cheap lithium instructions.

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

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
 #include "arm64/lithium-gap-resolver-arm64.h"
 #include "arm64/lithium-codegen-arm64.h"
 
 namespace v8 {
@@ skipping 23 matching lines @@
 
 void LGapResolver::Resolve(LParallelMove* parallel_move) {
   ASSERT(moves_.is_empty());
 
   // Build up a worklist of moves.
   BuildInitialMoveList(parallel_move);
 
   for (int i = 0; i < moves_.length(); ++i) {
     LMoveOperands move = moves_[i];
 
-    // Skip constants to perform them last. They don't block other moves
-    // and skipping such moves with register destinations keeps those
-    // registers free for the whole algorithm.
-    if (!move.IsEliminated() && !move.source()->IsConstantOperand()) {
+    // Skip constants and value regenerations to perform them last. They don't
+    // block other moves and skipping such moves with register destinations
+    // keeps those registers free for the whole algorithm.
+    if (!move.IsEliminated() &&
+        !move.UsesRegeneration() && !move.source()->IsConstantOperand()) {
       root_index_ = i;  // Any cycle is found when we reach this move again.
       PerformMove(i);
       if (in_cycle_) RestoreValue();
     }
   }
 
-  // Perform the moves with constant sources.
+  // Perform the moves with constant sources or regenerating the result.
   for (int i = 0; i < moves_.length(); ++i) {
     LMoveOperands move = moves_[i];
 
     if (!move.IsEliminated()) {
-      ASSERT(move.source()->IsConstantOperand());
+      ASSERT(move.UsesRegeneration() || move.source()->IsConstantOperand());
       EmitMove(i);
     }
   }
 
   if (need_to_restore_root_) {
     ASSERT(kSavedValue.Is(root));
     __ InitializeRootRegister();
     need_to_restore_root_ = false;
   }
 
@@ skipping 139 matching lines @@
 
   in_cycle_ = false;
   saved_destination_ = NULL;
 }
 
 
 void LGapResolver::EmitMove(int index) {
   LOperand* source = moves_[index].source();
   LOperand* destination = moves_[index].destination();
 
+  if (moves_[index].UsesRegeneration()) {
+    if (source->IsInRegister()) {
+      ASSERT(destination->IsInMemory());
+      if (source->parent_linstr()->hydrogen_value()->HasPhiUses()) {
+        // Phis insertion does not have access to the constant cache, so they
+        // won't be replaced by regenerations. If we skip the spill operation,
+        // the phi would then load garbage from the stack.
+      } else {
+        // Skip the store to memory. All gaps loading this value will instead
+        // regenerate it.
+        moves_[index].Eliminate();
+        return;
+      }
+    } else {
+      ASSERT(source->IsInMemory() && destination->IsInRegister());
+      ASSERT(destination->parent_linstr()->HasResult());
+      LTemplateResultInstruction<1>* instr =
+          reinterpret_cast<LTemplateResultInstruction<1>*>(
+              destination->parent_linstr());
+      ASSERT(instr->PreferRegenerateToSpill());
+      LOperand* prev_result = instr->result();
+      instr->set_result(destination);
+      instr->CompileToNative(cgen_);
+      instr->set_result(prev_result);
+      moves_[index].Eliminate();
+      return;
+    }
+  }
+
   // Dispatch on the source and destination operand kinds.  Not all
   // combinations are possible.
 
   if (source->IsRegister()) {
     Register source_register = cgen_->ToRegister(source);
     if (destination->IsRegister()) {
       __ Mov(cgen_->ToRegister(destination), source_register);
     } else {
       ASSERT(destination->IsStackSlot());
       __ Str(source_register, cgen_->ToMemOperand(destination));
@@ skipping 73 matching lines @@
   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