Fix issue 962.

src/lithium-allocator.h

 // Copyright 2010 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 37 matching lines @@
 class LArgument;
 class LChunk;
 class LConstantOperand;
 class LGap;
 class LInstruction;
 class LParallelMove;
 class LPointerMap;
 class LStackSlot;
 class LRegister;
 
+
 // This class represents a single point of a LOperand's lifetime.
 // For each lithium instruction there are exactly two lifetime positions:
 // the beginning and the end of the instruction. Lifetime positions for
 // different lithium instructions are disjoint.
 class LifetimePosition {
  public:
   // Return the lifetime position that corresponds to the beginning of
   // the instruction with the given index.
   static LifetimePosition FromInstructionIndex(int index) {
     return LifetimePosition(index * kStep);
@@ skipping 46 matching lines @@
   }
 
   // Constructs the lifetime position which does not correspond to any
   // instruction.
   LifetimePosition() : value_(-1) {}
 
   // Returns true if this lifetime positions corrensponds to some
   // instruction.
   bool IsValid() const { return value_ != -1; }
 
-  static LifetimePosition Invalid() { return LifetimePosition(); }
+  static inline LifetimePosition Invalid() { return LifetimePosition(); }

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

I don't usually write inline here.

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

I prefer to state intention clearly.

+
+  static inline LifetimePosition MaxPosition() {
+    // We have to use this kind of getter instead of static member due to
+    // crash bug in GDB.
+    return LifetimePosition(kMaxInt);
+  }
 
  private:
   static const int kStep = 2;
 
   // Code relies on kStep being a power of two.
   STATIC_ASSERT(IS_POWER_OF_TWO(kStep));
 
   explicit LifetimePosition(int value) : value_(value) { }
 
   int value_;
 };
 
 
+enum RegistersClass {

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

RegisterKind?

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  NONE,
+  CPU_REGISTERS,

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

Maybe GENERAL_REGISTERS is better?  They're all CPU registers :)

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  DOUBLE_REGISTERS
+};
+
+
 class LOperand: public ZoneObject {
  public:
   enum Kind {
     INVALID,
     UNALLOCATED,
     CONSTANT_OPERAND,
     STACK_SLOT,
     DOUBLE_STACK_SLOT,
     REGISTER,
     DOUBLE_REGISTER,
@@ skipping 439 matching lines @@
 
 // Representation of SSA values' live ranges as a collection of (continuous)
 // intervals over the instruction ordering.
 class LiveRange: public ZoneObject {
  public:
   static const int kInvalidAssignment = 0x7fffffff;
 
   explicit LiveRange(int id)
       : id_(id),
         spilled_(false),
-        assigned_double_(false),
         assigned_register_(kInvalidAssignment),
+        assigned_register_class_(NONE),

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

assigned_register_kind_?

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

         last_interval_(NULL),
         first_interval_(NULL),
         first_pos_(NULL),
         parent_(NULL),
         next_(NULL),
         current_interval_(NULL),
         last_processed_use_(NULL),
         spill_start_index_(kMaxInt) {
     spill_operand_ = new LUnallocated(LUnallocated::IGNORE);
   }
 
   UseInterval* first_interval() const { return first_interval_; }
   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; }
   bool IsParent() const { return parent() == NULL; }
   int id() const { return id_; }
   bool IsFixed() const { return id_ < 0; }
   bool IsEmpty() const { return first_interval() == NULL; }
   LOperand* CreateAssignedOperand();
   int assigned_register() const { return assigned_register_; }
   int spill_start_index() const { return spill_start_index_; }
-  void set_assigned_register(int reg, bool double_reg) {
+  void set_assigned_register(int reg, RegistersClass reg_class) {
     ASSERT(!HasRegisterAssigned() && !IsSpilled());
     assigned_register_ = reg;
-    assigned_double_ = double_reg;
+    assigned_register_class_ = reg_class;
     ConvertOperands();
   }
   void MakeSpilled() {
     ASSERT(!IsSpilled());
     ASSERT(TopLevel()->HasAllocatedSpillOperand());
     spilled_ = true;
     assigned_register_ = kInvalidAssignment;
     ConvertOperands();
   }
 
   // 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);
 
   // Returns use position for which register is required in this live
   // range and which follows both start and last processed use position
   // Modifies internal state of live range!
   UsePosition* NextRegisterPosition(LifetimePosition start);
 
   // Returns use position for which register is beneficial in this live
   // range and which follows both start and last processed use position
   // Modifies internal state of live range!
   UsePosition* NextUsePositionRegisterIsBeneficial(LifetimePosition start);
 
   // Can this live range be spilled at this position.
   bool CanBeSpilled(LifetimePosition pos);
 
+  // Split this live range at given position which must follow start of

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

follow the start of

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  // the range.
+  // All uses following the given position will be moved from this
+  // live range to result live range.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

to the result

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

   void SplitAt(LifetimePosition position, LiveRange* result);
 
-  bool IsDouble() const { return assigned_double_; }
+  bool IsDouble() const { return assigned_register_class_ == DOUBLE_REGISTERS; }
   bool HasRegisterAssigned() const {
     return assigned_register_ != kInvalidAssignment;
   }
   bool IsSpilled() const { return spilled_; }
   UsePosition* FirstPosWithHint() const;
 
   LOperand* FirstHint() const {
     UsePosition* pos = FirstPosWithHint();
     if (pos != NULL) return pos->hint();
     return NULL;
@@ skipping 46 matching lines @@
 #endif
 
  private:
   void ConvertOperands();
   UseInterval* FirstSearchIntervalForPosition(LifetimePosition position) const;
   void AdvanceLastProcessedMarker(UseInterval* to_start_of,
                                   LifetimePosition but_not_past) const;
 
   int id_;
   bool spilled_;
-  bool assigned_double_;
   int assigned_register_;
+  RegistersClass assigned_register_class_;
   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_;
@@ skipping 31 matching lines @@
   void RecordDefinition(HInstruction* instr, LUnallocated* operand);
   // Record a temporary operand.
   void RecordTemporary(LUnallocated* operand);
 
   // Marks the current instruction as a call.
   void MarkAsCall();
 
   // Checks whether the value of a given virtual register is tagged.
   bool HasTaggedValue(int virtual_register) const;
 
-  // Checks whether the value of a given virtual register is a double.
-  bool HasDoubleValue(int virtual_register) const;
+  // Returns register class required by given virtual register.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

Returns the register kind

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  RegistersClass RequiredRegisterClass(int virtual_register) const;
 
   // Begin a new instruction.
   void BeginInstruction();
 
   // Summarize the current instruction.
   void SummarizeInstruction(int index);
 
   // Summarize the current instruction.
   void OmitInstruction();
 
@@ skipping 18 matching lines @@
     ASSERT(!has_osr_entry_);
     // Simply set a flag to find and process instruction later.
     has_osr_entry_ = true;
   }
 
 #ifdef DEBUG
   void Verify() const;
 #endif
 
  private:
-  enum OperationMode {
-    NONE,
-    CPU_REGISTERS,
-    XMM_REGISTERS
-  };
-
   void MeetRegisterConstraints();
   void ResolvePhis();
   void BuildLiveRanges();
   void AllocateGeneralRegisters();
   void AllocateDoubleRegisters();
   void ConnectRanges();
   void ResolveControlFlow();
   void PopulatePointerMaps();
   void ProcessOsrEntry();
   void AllocateRegisters();
@@ skipping 31 matching lines @@
   void ActiveToHandled(LiveRange* range);
   void ActiveToInactive(LiveRange* range);
   void InactiveToHandled(LiveRange* range);
   void InactiveToActive(LiveRange* range);
   void FreeSpillSlot(LiveRange* range);
   LOperand* TryReuseSpillSlot(LiveRange* range);
 
   // Helper methods for allocating registers.
   bool TryAllocateFreeReg(LiveRange* range);
   void AllocateBlockedReg(LiveRange* range);
-  void SplitAndSpillIntersecting(LiveRange* range);
+
+  // Live range splitting helpers.
+
+  // Split given range at position pos.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

the given range

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  // If range starts at pos or range start follows pos then

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

Something like: If the range starts at or after pos then the original range....

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  // original range is returned.
+  // Otherwise returns live range that starts at pos and contains

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

the live range

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  // all uses from original range that follow pos. Uses at pos will

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

from the origiinal

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  // still be owned by original range after splitting.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

by the original

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  LiveRange* SplitAt(LiveRange* range, LifetimePosition pos);
+
+  // Split given range in position from interval [start, end].
+  LiveRange* SplitBetween(LiveRange* range,
+                          LifetimePosition start,
+                          LifetimePosition end);
+
+  // Find lifetime position in interval [start, end] that
+  // is optimal for splitting: it is either header of outermost
+  // loop covered by this interval or latest possible position.
   LifetimePosition FindOptimalSplitPos(LifetimePosition start,
                                        LifetimePosition end);
-  LiveRange* Split(LiveRange* range,
-                   LifetimePosition start,
-                   LifetimePosition end);
-  LiveRange* Split(LiveRange* range, LifetimePosition split_pos);
-  void SplitAndSpill(LiveRange* range,
-                     LifetimePosition start,
-                     LifetimePosition end);
-  void SplitAndSpill(LiveRange* range, LifetimePosition at);
+
+  // Spill give life range after position pos.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

the given live range

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  void SpillAfter(LiveRange* range, LifetimePosition pos);
+
+  // Spill given life range after position start and up to end.

[Kevin Millikin (Chromium), 2010/12/10 07:39:19]

the given live range

[Vyacheslav Egorov (Chromium), 2010/12/10 14:18:27]

Done.

+  void SpillBetween(LiveRange* range,
+                    LifetimePosition start,
+                    LifetimePosition end);
+
+
+  void SplitAndSpillIntersecting(LiveRange* range);
+
   void Spill(LiveRange* range);
   bool IsBlockBoundary(LifetimePosition pos);
   void AddGapMove(int pos, LiveRange* prev, LiveRange* next);
 
   // Helper methods for resolving control flow.
   void ResolveControlFlow(LiveRange* range,
                           HBasicBlock* block,
                           HBasicBlock* pred);
 
   // Return parallel move that should be used to connect ranges split at the
@@ skipping 36 matching lines @@
   ZoneList<LiveRange*> fixed_live_ranges_;
   ZoneList<LiveRange*> fixed_double_live_ranges_;
   ZoneList<LiveRange*> unhandled_live_ranges_;
   ZoneList<LiveRange*> active_live_ranges_;
   ZoneList<LiveRange*> inactive_live_ranges_;
   ZoneList<LiveRange*> reusable_slots_;
 
   // Next virtual register number to be assigned to temporaries.
   int next_virtual_register_;
 
-  OperationMode mode_;
+  RegistersClass mode_;
   int num_registers_;
 
   HGraph* graph_;
 
   bool has_osr_entry_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_