Initialize zone lists in the register allocator with more reasonable initial ...

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 410 matching lines @@
     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),
-        live_in_sets_(0),
-        live_ranges_(16),
-        fixed_live_ranges_(8),
-        fixed_double_live_ranges_(8),
-        unhandled_live_ranges_(8),
-        active_live_ranges_(8),
-        inactive_live_ranges_(8),
-        reusable_slots_(8),
-        next_virtual_register_(first_virtual_register),
-        first_artificial_register_(first_virtual_register),
-        mode_(NONE),
-        num_registers_(-1),
-        graph_(graph),
-        has_osr_entry_(false) {}
+  LAllocator(int first_virtual_register, HGraph* graph);
 
   static void Setup();
   static void TraceAlloc(const char* msg, ...);
 
   // Lithium translation support.
   // Record a use of an input operand in the current instruction.
   void RecordUse(HValue* value, LUnallocated* operand);
   // Record the definition of the output operand.
   void RecordDefinition(HInstruction* instr, LUnallocated* operand);
   // Record a temporary operand.
   void RecordTemporary(LUnallocated* operand);
 
   // Checks whether the value of a given virtual register is tagged.
   bool HasTaggedValue(int virtual_register) const;
 
   // Returns the register kind required by the given virtual register.
   RegisterKind RequiredRegisterKind(int virtual_register) const;
 
   // Control max function size.
   static int max_initial_value_ids();
 
   void Allocate(LChunk* chunk);
 
   const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
-  const ZoneList<LiveRange*>* fixed_live_ranges() const {
+  const Vector<LiveRange*>* fixed_live_ranges() const {
     return &fixed_live_ranges_;
   }
-  const ZoneList<LiveRange*>* fixed_double_live_ranges() const {
+  const Vector<LiveRange*>* fixed_double_live_ranges() const {
     return &fixed_double_live_ranges_;
   }
 
   LChunk* chunk() const { return chunk_; }
   HGraph* graph() const { return graph_; }
 
   void MarkAsOsrEntry() {
     // There can be only one.
     ASSERT(!has_osr_entry_);
     // Simply set a flag to find and process instruction later.
@@ skipping 124 matching lines @@
   LChunk* chunk_;
 
   // During liveness analysis keep a mapping from block id to live_in sets
   // for blocks already analyzed.
   ZoneList<BitVector*> live_in_sets_;
 
   // Liveness analysis results.
   ZoneList<LiveRange*> live_ranges_;
 
   // Lists of live ranges
-  ZoneList<LiveRange*> fixed_live_ranges_;
-  ZoneList<LiveRange*> fixed_double_live_ranges_;
+  EmbeddedVector<LiveRange*,

[Kevin Millikin (Chromium), 2011/03/10 11:23:08]

No matter what you do here, it will be a nasty line break.  I like to break at
the lowest precedence operator that makes it fit on the fewest lines.  Here, the
lowest precedence ought to be the space between the type and identifier:

EmbeddedVector<LiveRange*, Register::kNumAllocatableRegisters>
    fixed_live_ranges_;

I like that a little better, but what do you think?

[fschneider, 2011/03/10 12:04:16]

I'm fine with both.

+      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_;
 
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(LAllocator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_ALLOCATOR_H_