Remember required register kind when creating artificial virtual register.

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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_LITHIUM_ALLOCATOR_H_
 #define V8_LITHIUM_ALLOCATOR_H_
 
 #include "v8.h"
 
+#include "data-flow.h"
 #include "zone.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class HBasicBlock;
 class HGraph;
 class HInstruction;
 class HPhi;
@@ skipping 704 matching lines @@
   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_;
 };
 
 
+class FlexibleBitVector BASE_EMBEDDED {

[Kevin Millikin (Chromium), 2011/01/03 16:44:46]

Maybe GrowableBitVector is more descriptive?  It never shrinks, does it?

+ public:
+  FlexibleBitVector() : bits_(NULL) { }
+
+  bool Contains(int value) const {

[Kevin Millikin (Chromium), 2011/01/03 16:44:46]

Maybe it's too cute, but you could make this class more specialized and have it
handle the scaling (storing first_artificial_register_ and subtracting it in the
Contains and Add functions).

+    if (!InBitsRange(value)) return false;
+    return bits_->Contains(value);
+  }
+
+  void Add(int value) {
+    EnsureCapacity(value);
+    bits_->Add(value);
+  }
+
+ private:
+  static const int kInitialLength = 1024;

[Kevin Millikin (Chromium), 2011/01/03 16:44:46]

This seems like a big initial length.

+
+  bool InBitsRange(int value) const {
+    return bits_ != NULL && bits_->length() > value;
+  }
+
+  void EnsureCapacity(int value) {
+    if (InBitsRange(value)) return;
+    int new_length = bits_ == NULL ? kInitialLength : bits_->length();
+    while (new_length <= value) new_length *= 2;
+    BitVector* new_bits = new BitVector(new_length);
+    if (bits_ != NULL) new_bits->CopyFrom(*bits_);
+    bits_ = new_bits;
+  }
+
+  BitVector* bits_;
+};
+
+
 class LAllocator BASE_EMBEDDED {
  public:
   explicit LAllocator(int first_virtual_register, HGraph* graph)
       : chunk_(NULL),
         summaries_(0),
         next_summary_(NULL),
         summary_stack_(2),
         live_in_sets_(0),
         live_ranges_(16),
         fixed_live_ranges_(8),
@@ skipping 198 matching lines @@
   // Lists of live ranges
   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_;
+  int first_artificial_register_;

[Kevin Millikin (Chromium), 2011/01/03 16:44:46]

I'd be more comfortable with an initial value, even if invalid.

+  FlexibleBitVector double_artificial_registers_;
 
   RegisterKind mode_;
   int num_registers_;
 
   HGraph* graph_;
 
   bool has_osr_entry_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_