For the values defined in the loop and spilled outside sink spill store out of the loop down to loo…

src/lithium-allocator.h

 // Copyright 2012 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 272 matching lines @@
   UsePosition* first_pos() const { return first_pos_; }
   LiveRange* parent() const { return parent_; }
   LiveRange* TopLevel() { return (parent_ == NULL) ? this : parent_; }
   LiveRange* next() const { return next_; }
   bool IsChild() const { return parent() != NULL; }
   int id() const { return id_; }
   bool IsFixed() const { return id_ < 0; }
   bool IsEmpty() const { return first_interval() == NULL; }
   LOperand* CreateAssignedOperand(Zone* zone);
   int assigned_register() const { return assigned_register_; }
+
   int spill_start_index() const { return spill_start_index_; }
+  void set_spill_start_index(int start) { spill_start_index_ = start; }
+
   void set_assigned_register(int reg,
                              RegisterKind register_kind,
                              Zone* zone);
   void MakeSpilled(Zone* zone);
 
   // Returns use position in this live range that follows both start
   // and last processed use position.
   // Modifies internal state of live range!
   UsePosition* NextUsePosition(LifetimePosition start);
 
@@ skipping 36 matching lines @@
 
   LifetimePosition End() const {
     ASSERT(!IsEmpty());
     return last_interval_->end();
   }
 
   bool HasAllocatedSpillOperand() const;
   LOperand* GetSpillOperand() const { return spill_operand_; }
   void SetSpillOperand(LOperand* operand);
 
-  void SetSpillStartIndex(int start) {
-    spill_start_index_ = Min(start, spill_start_index_);
-  }
-
   bool ShouldBeAllocatedBefore(const LiveRange* other) const;
   bool CanCover(LifetimePosition position) const;
   bool Covers(LifetimePosition position);
   LifetimePosition FirstIntersection(LiveRange* other);
 
   // Add a new interval or a new use position to this live range.
   void EnsureInterval(LifetimePosition start,
                       LifetimePosition end,
                       Zone* zone);
   void AddUseInterval(LifetimePosition start,
                       LifetimePosition end,
                       Zone* zone);
   UsePosition* AddUsePosition(LifetimePosition pos,
                               LOperand* operand,
                               Zone* zone);
 
   // Shorten the most recently added interval by setting a new start.
   void ShortenTo(LifetimePosition start);
 
 #ifdef DEBUG
   // True if target overlaps an existing interval.
   bool HasOverlap(UseInterval* target) const;
   void Verify() const;
 #endif
 
+  static const intptr_t kDisabledSpillStoreSinkingMarker = -1;
+
+  LOperand* spill_source() { return spill_source_; }
+  void set_spill_source(LOperand* spill_source) {
+    spill_source_ = spill_source;
+  }
+
+  bool HasPendingSpillStore() {
+    return (spill_source() !=
+            reinterpret_cast<LOperand*>(kDisabledSpillStoreSinkingMarker)) &&
+        (spill_source() != NULL);
+  }
+
+  void DisableSpillStoreSinking() {
+    set_spill_source(
+        reinterpret_cast<LOperand*>(kDisabledSpillStoreSinkingMarker));
+  }
+
  private:
   void ConvertOperands(Zone* zone);
   UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const;
   void AdvanceLastProcessedMarker(UseInterval* to_start_of,
                                   LifetimePosition but_not_past) const;
 
   int id_;
   bool spilled_;
   bool is_double_;
   int assigned_register_;
   UseInterval* last_interval_;
   UseInterval* first_interval_;
   UsePosition* first_pos_;
   LiveRange* parent_;
   LiveRange* next_;
   // This is used as a cache, it doesn't affect correctness.
   mutable UseInterval* current_interval_;
   UsePosition* last_processed_use_;
   LOperand* spill_operand_;
   int spill_start_index_;
+  LOperand* spill_source_;
 };
 
 
 class GrowableBitVector BASE_EMBEDDED {
  public:
   GrowableBitVector() : bits_(NULL) { }
 
   bool Contains(int value) const {
     if (!InBitsRange(value)) return false;
     return bits_->Contains(value);
@@ skipping 148 matching lines @@
   void SpillAfter(LiveRange* range, LifetimePosition pos);
 
   // Spill the given life range after position start and up to position end.
   void SpillBetween(LiveRange* range,
                     LifetimePosition start,
                     LifetimePosition end);
 
   void SplitAndSpillIntersecting(LiveRange* range);
 
   void Spill(LiveRange* range);
+
+  // Emit spill store for the given range that moves value from the register
+  // where it was produced (spill source) to the allocated spill slot.
+  void EmitSpillStore(LiveRange* range);
+  void EmitSpillStore(int pos, LOperand* source, LOperand* spill);
+
+  // Try sink spill store for the given range down to the beginning of the
+  // given block. This is done only if the block dominates all spilled split
+  // siblings.
+  bool TrySinkSpillStoreTo(LiveRange* range, HBasicBlock* block);
+
   bool IsBlockBoundary(LifetimePosition pos);
 
   // Helper methods for resolving control flow.
   void ResolveControlFlow(LiveRange* range,
                           HBasicBlock* block,
                           HBasicBlock* pred);
 
+  // Emit all pending spill stores for ranges that have spilled siblings sinking
+  // stores down to loop exits whenever possible.
+  void SinkSpillStores();
+
   // Return parallel move that should be used to connect ranges split at the
   // given position.
   LParallelMove* GetConnectingParallelMove(LifetimePosition pos);
 
   // Return the block which contains give lifetime position.
   HBasicBlock* GetBlock(LifetimePosition pos);
 
   // Helper methods for the fixed registers.
   int RegisterCount() const;
   static int FixedLiveRangeID(int index) { return -index - 1; }
@@ skipping 26 matching lines @@
   // Lists of live ranges
   EmbeddedVector<LiveRange*, Register::kNumAllocatableRegisters>
       fixed_live_ranges_;
   EmbeddedVector<LiveRange*, DoubleRegister::kNumAllocatableRegisters>
       fixed_double_live_ranges_;
   ZoneList<LiveRange*> unhandled_live_ranges_;
   ZoneList<LiveRange*> active_live_ranges_;
   ZoneList<LiveRange*> inactive_live_ranges_;
   ZoneList<LiveRange*> reusable_slots_;
 
+  // List of live ranges that were spilled but did not have
+  // spill store emitted eagerly.
+  ZoneList<LiveRange*> pending_spilled_;
+
   // Next virtual register number to be assigned to temporaries.
   int next_virtual_register_;
   int first_artificial_register_;
   GrowableBitVector double_artificial_registers_;
 
   RegisterKind mode_;
   int num_registers_;
 
   HGraph* graph_;
 
   bool has_osr_entry_;
 
   // Indicates success or failure during register allocation.
   bool allocation_ok_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_