Implement basic support for deferred slow path code with calls that save and restore live registers.

runtime/vm/flow_graph_allocator.h

 // Copyright (c) 2012, 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.
 
 #ifndef VM_FLOW_GRAPH_ALLOCATOR_H_
 #define VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 78 matching lines @@
 
   // Visit instructions in the postorder and build live ranges for
   // all SSA values.
   void BuildLiveRanges();
   Instruction* ConnectOutgoingPhiMoves(BlockEntryInstr* block);
   void ProcessEnvironmentUses(BlockEntryInstr* block, Instruction* current);
   void ProcessOneInstruction(BlockEntryInstr* block, Instruction* instr);
   void ConnectIncomingPhiMoves(BlockEntryInstr* block);
   void BlockLocation(Location loc, intptr_t from, intptr_t to);
 
+  // Find all safepoints that are covered by this live range.
+  void AssignSafepoints(LiveRange* range);
+
   // Process live ranges sorted by their start and assign registers
   // to them
   void AllocateCPURegisters();
   void AdvanceActiveIntervals(const intptr_t start);
 
   // Connect split siblings over non-linear control flow edges.
   void ResolveControlFlow();
   void ConnectSplitSiblings(LiveRange* range,
                             BlockEntryInstr* source_block,
                             BlockEntryInstr* target_block);
@@ skipping 97 matching lines @@
   GrowableArray<LiveRange*> live_ranges_;
 
   // Worklist for register allocator. Always maintained sorted according
   // to ShouldBeAllocatedBefore predicate.
   GrowableArray<LiveRange*> unallocated_;
 
 #if defined(DEBUG)
   GrowableArray<LiveRange*> temporaries_;
 #endif
 
+  // List of spilled live ranges.
   GrowableArray<LiveRange*> spilled_;
 
+  // List of instructions containing calls.
+  GrowableArray<Instruction*> safepoints_;
+
   // Per register lists of allocated live ranges.  Contain only those
   // ranges that can be affected by future allocation decisions.
   // Those live ranges that end before the start of the current live range are
   // removed from the list and will not be affected.
   GrowableArray<LiveRange*> cpu_regs_[kNumberOfCpuRegisters];
 
   // List of used spill slots. Contains positions after which spill slots
   // become free and can be reused for allocation.
   GrowableArray<intptr_t> spill_slots_;
 
-  // List of safepoints.
-  struct Safepoint {
-    intptr_t position;
-    BitmapBuilder* stack_bitmap;
-  };
-  GrowableArray<Safepoint> safepoints_;
-
   bool blocked_cpu_regs_[kNumberOfCpuRegisters];
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphAllocator);
 };
 
 
 // Additional information about a block that is not contained in a
 // block entry.
 class BlockInfo : public ZoneAllocated {
  public:
@@ skipping 135 matching lines @@
  private:
   UseInterval* first_pending_use_interval_;
   UsePosition* first_register_use_;
   UsePosition* first_register_beneficial_use_;
   UsePosition* first_hinted_use_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationFinger);
 };
 
 
+class SafepointPosition : public ZoneAllocated {

[srdjan, 2012/08/15 00:12:03]

Make a common superclass PositionsList (subclasses UsePosition, SafePosition),
and replace the template function for splitting the list

+ public:
+  SafepointPosition(intptr_t pos,
+                    LocationSummary* locs)
+      : pos_(pos), locs_(locs), next_(NULL) { }
+
+  void set_next(SafepointPosition* next) { next_ = next; }
+  SafepointPosition* next() const { return next_; }
+
+  intptr_t pos() const { return pos_; }
+
+  LocationSummary* locs() const { return locs_; }
+
+ private:
+  const intptr_t pos_;
+  LocationSummary* const locs_;
+
+  SafepointPosition* next_;
+};
+
+
 // LiveRange represents a sequence of UseIntervals for a given SSA value.
 class LiveRange : public ZoneAllocated {
  public:
   explicit LiveRange(intptr_t vreg)
     : vreg_(vreg),
       assigned_location_(),
       spill_slot_(),
       uses_(NULL),
       first_use_interval_(NULL),
       last_use_interval_(NULL),
+      first_safepoint_(NULL),
+      last_safepoint_(NULL),
       next_sibling_(NULL),
       finger_() {
   }
 
   static LiveRange* MakeTemp(intptr_t pos, Location* location_slot);
 
   intptr_t vreg() const { return vreg_; }
   LiveRange* next_sibling() const { return next_sibling_; }
   UsePosition* first_use() const { return uses_; }
   void set_first_use(UsePosition* use) { uses_ = use; }
   UseInterval* first_use_interval() const { return first_use_interval_; }
   UseInterval* last_use_interval() const { return last_use_interval_; }
   Location assigned_location() const { return assigned_location_; }
   intptr_t Start() const { return first_use_interval()->start(); }
   intptr_t End() const { return last_use_interval()->end(); }
 
+  SafepointPosition* first_safepoint() const { return first_safepoint_; }
+
   AllocationFinger* finger() { return &finger_; }
 
   void set_assigned_location(Location location) {
     assigned_location_ = location;
   }
 
   void set_spill_slot(Location spill_slot) {
     spill_slot_ = spill_slot;
   }
 
   void DefineAt(intptr_t pos);
 
+  void AddSafepoint(intptr_t pos, LocationSummary* locs);
+
   void AddUse(intptr_t pos, Location* location_slot);
   void AddHintedUse(intptr_t pos, Location* location_slot, Location* hint);
 
   void AddUseInterval(intptr_t start, intptr_t end);
 
   void Print();
 
   void AssignLocation(UseInterval* use, Location loc);
 
   LiveRange* SplitAt(intptr_t pos);
@@ skipping 10 matching lines @@
 
   Location spill_slot() const {
     return spill_slot_;
   }
 
  private:
   LiveRange(intptr_t vreg,
             UsePosition* uses,
             UseInterval* first_use_interval,
             UseInterval* last_use_interval,
+            SafepointPosition* first_safepoint,
             LiveRange* next_sibling)
     : vreg_(vreg),
       assigned_location_(),
       uses_(uses),
       first_use_interval_(first_use_interval),
       last_use_interval_(last_use_interval),
+      first_safepoint_(first_safepoint),
+      last_safepoint_(NULL),
       next_sibling_(next_sibling),
       finger_() {
   }
 
   const intptr_t vreg_;
   Location assigned_location_;
   Location spill_slot_;
 
   UsePosition* uses_;
   UseInterval* first_use_interval_;
   UseInterval* last_use_interval_;
 
+  SafepointPosition* first_safepoint_;
+  SafepointPosition* last_safepoint_;
+
   LiveRange* next_sibling_;
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_