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

src/lithium-allocator.cc

 // Copyright 2012 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 "lithium-allocator-inl.h"
 
 #include "hydrogen.h"
 #include "string-stream.h"
 
@@ skipping 106 matching lines @@
       assigned_register_(kInvalidAssignment),
       last_interval_(NULL),
       first_interval_(NULL),
       first_pos_(NULL),
       parent_(NULL),
       next_(NULL),
       current_interval_(NULL),
       last_processed_use_(NULL),
       current_hint_operand_(NULL),
       spill_operand_(new(zone) LOperand()),
-      spill_start_index_(kMaxInt) { }
+      spill_start_index_(kMaxInt),
+      parent_linstr_(NULL) { }
 
 
 void LiveRange::set_assigned_register(int reg, Zone* zone) {
   ASSERT(!HasRegisterAssigned() && !IsSpilled());
   assigned_register_ = reg;
   ConvertOperands(zone);
 }
 
 
 void LiveRange::MakeSpilled(Zone* zone) {
   ASSERT(!IsSpilled());
   ASSERT(TopLevel()->HasAllocatedSpillOperand());
   spilled_ = true;
   assigned_register_ = kInvalidAssignment;
   ConvertOperands(zone);
+  spill_operand_->set_parent_linstr(parent_linstr());
 }
 
 
 bool LiveRange::HasAllocatedSpillOperand() const {
   ASSERT(spill_operand_ != NULL);
   return !spill_operand_->IsIgnored();
 }
 
 
 void LiveRange::SetSpillOperand(LOperand* operand) {
   ASSERT(!operand->IsUnallocated());
   ASSERT(spill_operand_ != NULL);
   ASSERT(spill_operand_->IsIgnored());
+  ASSERT((spill_operand_->parent_linstr() == NULL) ||
+         (spill_operand_->parent_linstr() == parent_linstr()));
   spill_operand_->ConvertTo(operand->kind(), operand->index());
+  spill_operand_->set_parent_linstr(parent_linstr());
 }
 
 
 UsePosition* LiveRange::NextUsePosition(LifetimePosition start) {
   UsePosition* use_pos = last_processed_use_;
   if (use_pos == NULL) use_pos = first_pos();
   while (use_pos != NULL && use_pos->pos().Value() < start.Value()) {
     use_pos = use_pos->next();
   }
   last_processed_use_ = use_pos;
@@ skipping 37 matching lines @@
   // at the current or the immediate next position.
   UsePosition* use_pos = NextRegisterPosition(pos);
   if (use_pos == NULL) return true;
   return
       use_pos->pos().Value() > pos.NextInstruction().InstructionEnd().Value();
 }
 
 
 LOperand* LiveRange::CreateAssignedOperand(Zone* zone) {
   LOperand* op = NULL;
+  bool allow_use_cache = parent_linstr() == NULL;
   if (HasRegisterAssigned()) {
     ASSERT(!IsSpilled());
     switch (Kind()) {
       case GENERAL_REGISTERS:
-        op = LRegister::Create(assigned_register(), zone);
+        op = LRegister::Create(assigned_register(), zone, allow_use_cache);
         break;
       case DOUBLE_REGISTERS:
-        op = LDoubleRegister::Create(assigned_register(), zone);
+        op = LDoubleRegister::Create(assigned_register(), zone,
+                                     allow_use_cache);
         break;
       default:
         UNREACHABLE();
     }
   } else if (IsSpilled()) {
     ASSERT(!HasRegisterAssigned());
     op = TopLevel()->GetSpillOperand();
     ASSERT(!op->IsUnallocated());
+    ASSERT(op->parent_linstr() == parent_linstr());
   } else {
     LUnallocated* unalloc = new(zone) LUnallocated(LUnallocated::NONE);
     unalloc->set_virtual_register(id_);
     op = unalloc;
   }
+  op->set_parent_linstr(parent_linstr());
   return op;
 }
 
 
 UseInterval* LiveRange::FirstSearchIntervalForPosition(
     LifetimePosition position) const {
   if (current_interval_ == NULL) return first_interval_;
   if (current_interval_->start().Value() > position.Value()) {
     current_interval_ = NULL;
     return first_interval_;
@@ skipping 13 matching lines @@
     current_interval_ = to_start_of;
   }
 }
 
 
 void LiveRange::SplitAt(LifetimePosition position,
                         LiveRange* result,
                         Zone* zone) {
   ASSERT(Start().Value() < position.Value());
   ASSERT(result->IsEmpty());
+
+  result->set_parent_linstr(parent_linstr());
+
   // Find the last interval that ends before the position. If the
   // position is contained in one of the intervals in the chain, we
   // split that interval and use the first part.
   UseInterval* current = FirstSearchIntervalForPosition(position);
 
   // If the split position coincides with the beginning of a use interval
   // we need to split use positons in a special way.
   bool split_at_start = false;
 
   if (current->start().Value() == position.Value()) {
@@ skipping 408 matching lines @@
   int index = LUnallocated::cast(operand)->virtual_register();
   HValue* instr = graph_->LookupValue(index);
   if (instr != NULL && instr->IsPhi()) {
     return HPhi::cast(instr);
   }
   return NULL;
 }
 
 
 LiveRange* LAllocator::LiveRangeFor(LOperand* operand) {
+  LiveRange* result;
   if (operand->IsUnallocated()) {
-    return LiveRangeFor(LUnallocated::cast(operand)->virtual_register());
+    result = LiveRangeFor(LUnallocated::cast(operand)->virtual_register());
   } else if (operand->IsRegister()) {
-    return FixedLiveRangeFor(operand->index());
+    result = FixedLiveRangeFor(operand->index());
   } else if (operand->IsDoubleRegister()) {
-    return FixedDoubleLiveRangeFor(operand->index());
+    result = FixedDoubleLiveRangeFor(operand->index());
   } else {
     return NULL;
   }
+  result->set_parent_linstr(operand->parent_linstr());
+  return result;
 }
 
 
 void LAllocator::Define(LifetimePosition position,
                         LOperand* operand,
                         LOperand* hint) {
   LiveRange* range = LiveRangeFor(operand);
   if (range == NULL) return;
 
   if (range->IsEmpty() || range->Start().Value() > position.Value()) {
@@ skipping 998 matching lines @@
   return true;
 }
 
 
 void LAllocator::FreeSpillSlot(LiveRange* range) {
   // Check that we are the last range.
   if (range->next() != NULL) return;
 
   if (!range->TopLevel()->HasAllocatedSpillOperand()) return;
 
+  if (range->parent_linstr() != NULL) {
+    // Reusing live ranges with parent instruction information may prevent
+    // optimizing away gap moves.
+    return;
+  }
+
   int index = range->TopLevel()->GetSpillOperand()->index();
   if (index >= 0) {
     reusable_slots_.Add(range, zone());
   }
 }
 
 
 LOperand* LAllocator::TryReuseSpillSlot(LiveRange* range) {
   if (reusable_slots_.is_empty()) return NULL;
   if (reusable_slots_.first()->End().Value() >
@@ skipping 409 matching lines @@
     // Nothing to spill. Just put it to unhandled as whole.
     AddToUnhandledSorted(second_part);
   }
 }
 
 
 void LAllocator::Spill(LiveRange* range) {
   ASSERT(!range->IsSpilled());
   TraceAlloc("Spilling live range %d\n", range->id());
   LiveRange* first = range->TopLevel();
+  ASSERT(first->parent_linstr() == range->parent_linstr());
 
   if (!first->HasAllocatedSpillOperand()) {
     LOperand* op = TryReuseSpillSlot(range);
     if (op == NULL) op = chunk_->GetNextSpillSlot(range->Kind());
     first->SetSpillOperand(op);
   }
   range->MakeSpilled(chunk()->zone());
 }
 
 
@@ skipping 38 matching lines @@
     isolate()->GetHTracer()->TraceLiveRanges(name(), allocator_);
   }
 
 #ifdef DEBUG
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 
 } }  // namespace v8::internal