Add support for XMM registers in SSA code generation pipeline.

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 76 matching lines @@
   LiveRange* MakeLiveRangeForTemporary();
 
   // 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);
+  void BlockRegisterLocation(Location loc,
+                             intptr_t from,
+                             intptr_t to,
+                             bool* blocked_registers,
+                             LiveRange** blocking_ranges);
+
+  intptr_t NumberOfRegisters() const { return number_of_registers_; }
 
   // Find all safepoints that are covered by this live range.
   void AssignSafepoints(LiveRange* range);
 
+  void PrepareForAllocation(Location::Kind register_kind,
+                            intptr_t number_of_registers,
+                            const GrowableArray<LiveRange*>& unallocated,
+                            LiveRange** blocking_ranges,
+                            bool* blocked_registers);
+
+
   // Process live ranges sorted by their start and assign registers
   // to them
-  void AllocateCPURegisters();
+  void AllocateUnallocatedRanges();
   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);
 
 
   // Update location slot corresponding to the use with location allocated for
   // the use's live range.
   void ConvertUseTo(UsePosition* use, Location loc);
   void ConvertAllUses(LiveRange* range);
 
   // Add live range to the list of unallocated live ranges to be processed
   // by the allocator.
   void AddToUnallocated(LiveRange* range);
+  void CompleteRange(LiveRange* range, Location::Kind kind);
 #if defined(DEBUG)
   bool UnallocatedIsSorted();
 #endif
 
   // Try to find a free register for an unallocated live range.
   bool AllocateFreeRegister(LiveRange* unallocated);
 
   // Try to find a register that can be used by a given live range.
   // If all registers are occupied consider evicting interference for
   // a register that is going to be used as far from the start of
   // the unallocated live range as possible.
   void AllocateAnyRegister(LiveRange* unallocated);
 
   // Assign selected non-free register to an unallocated live range and
   // evict any interference that can be evicted by splitting and spilling
   // parts of interfering live ranges.  Place non-spilled parts into
   // the list of unallocated ranges.
-  void AssignNonFreeRegister(LiveRange* unallocated, Register reg);
+  void AssignNonFreeRegister(LiveRange* unallocated, intptr_t reg);
   bool EvictIntersection(LiveRange* allocated, LiveRange* unallocated);
-  void RemoveEvicted(Register reg, intptr_t first_evicted);
+  void RemoveEvicted(intptr_t reg, intptr_t first_evicted);
 
   // Find first intersection between unallocated live range and
   // live ranges currently allocated to the given register.
-  intptr_t FirstIntersectionWithAllocated(Register reg,
+  intptr_t FirstIntersectionWithAllocated(intptr_t reg,
                                           LiveRange* unallocated);
 
-  bool UpdateFreeUntil(Register reg,
+  bool UpdateFreeUntil(intptr_t reg,
                        LiveRange* unallocated,
                        intptr_t* cur_free_until,
                        intptr_t* cur_blocked_at);
 
   // Split given live range in an optimal position between given positions.
   LiveRange* SplitBetween(LiveRange* range, intptr_t from, intptr_t to);
 
   // Find a spill slot that can be used by the given live range.
   void AllocateSpillSlotFor(LiveRange* range);
 
   // Allocate the given live range to a spill slot.
   void Spill(LiveRange* range);
 
   // Spill the given live range from the given position onwards.
   void SpillAfter(LiveRange* range, intptr_t from);
 
   // Spill the given live range from the given position until some
   // position preceding the to position.
   void SpillBetween(LiveRange* range, intptr_t from, intptr_t to);
 
   // Mark the live range as a live object pointer at all safepoints
   // contained in the range.
   void MarkAsObjectAtSafepoints(LiveRange* range);
 
   MoveOperands* AddMoveAt(intptr_t pos, Location to, Location from);
 
+  Location MakeRegisterLocation(intptr_t reg) {
+    return Location::MachineRegisterLocation(register_kind_, reg);
+  }
+
   void PrintLiveRanges();
 
   const FlowGraph& flow_graph_;
   const GrowableArray<BlockEntryInstr*>& block_order_;
   const GrowableArray<BlockEntryInstr*>& postorder_;
 
   // Mapping between lifetime positions and instructions.
   GrowableArray<Instruction*> instructions_;
 
   // Mapping between lifetime positions and blocks containing them.
@@ skipping 13 matching lines @@
   // that are used by this block or its successors.
   GrowableArray<BitVector*> live_in_;
 
   // Number of virtual registers.  Currently equal to the number of
   // SSA values.
   const intptr_t vreg_count_;
 
   // LiveRanges corresponding to SSA values.
   GrowableArray<LiveRange*> live_ranges_;
 
-  // Worklist for register allocator. Always maintained sorted according
-  // to ShouldBeAllocatedBefore predicate.
-  GrowableArray<LiveRange*> unallocated_;
+  GrowableArray<LiveRange*> unallocated_cpu_;
+  GrowableArray<LiveRange*> unallocated_xmm_;
+
+  LiveRange* cpu_regs_[kNumberOfCpuRegisters];
+  LiveRange* xmm_regs_[kNumberOfXmmRegisters];
+
+  bool blocked_cpu_registers_[kNumberOfCpuRegisters];
+  bool blocked_xmm_registers_[kNumberOfXmmRegisters];
 
 #if defined(DEBUG)
   GrowableArray<LiveRange*> temporaries_;
 #endif
 
   // List of spilled live ranges.
   GrowableArray<LiveRange*> spilled_;
 
   // List of instructions containing calls.
   GrowableArray<Instruction*> safepoints_;
 
+  Location::Kind register_kind_;
+
+  intptr_t number_of_registers_;
+
   // 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];
+  GrowableArray<LiveRange*> registers_[kNumberOfCpuRegisters];
+
+  bool blocked_registers_[kNumberOfCpuRegisters];
+
+
+  // Worklist for register allocator. Always maintained sorted according
+  // to ShouldBeAllocatedBefore predicate.
+  GrowableArray<LiveRange*> unallocated_;
 
   // List of used spill slots. Contains positions after which spill slots
   // become free and can be reused for allocation.
   GrowableArray<intptr_t> spill_slots_;
+  intptr_t cpu_spill_slot_count_;
 
-  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:
   explicit BlockInfo(BlockEntryInstr* entry)
@@ skipping 26 matching lines @@
 
 
 // UsePosition represents a single use of an SSA value by some instruction.
 // It points to a location slot which either tells register allocator
 // where instruction expects the value (if slot contains a fixed location) or
 // asks register allocator to allocate storage (register or spill slot) for
 // this use with certain properties (if slot contains an unallocated location).
 class UsePosition : public ZoneAllocated {
  public:
   UsePosition(intptr_t pos, UsePosition* next, Location* location_slot)
-      : pos_(pos), location_slot_(location_slot), hint_(NULL), next_(next) { }
+      : pos_(pos), location_slot_(location_slot), hint_(NULL), next_(next) {
+    ASSERT(location_slot != NULL);
+  }
 
   Location* location_slot() const { return location_slot_; }
   void set_location_slot(Location* location_slot) {
     location_slot_ = location_slot;
   }
 
   Location hint() const {
     ASSERT(HasHint());
     return *hint_;
   }
@@ skipping 217 matching lines @@
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_