Refactor allocation policies.

src/lithium.h

 // Copyright 2011 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 369 matching lines @@
   static const int kNumCachedOperands = 16;
   static LDoubleRegister cache[];
 
   LDoubleRegister() : LOperand() { }
   explicit LDoubleRegister(int index) : LOperand(DOUBLE_REGISTER, index) { }
 };
 
 
 class LParallelMove : public ZoneObject {
  public:
-  LParallelMove() : move_operands_(4) { }
+  explicit LParallelMove(Zone* zone) : move_operands_(zone, 4) { }
 
   void AddMove(LOperand* from, LOperand* to) {
     move_operands_.Add(LMoveOperands(from, to));
   }
 
   bool IsRedundant() const;
 
   const ZoneList<LMoveOperands>* move_operands() const {
     return &move_operands_;
   }
 
   void PrintDataTo(StringStream* stream) const;
 
  private:
   ZoneList<LMoveOperands> move_operands_;
 };
 
 
 class LPointerMap: public ZoneObject {
  public:
-  explicit LPointerMap(int position)
-      : pointer_operands_(8), position_(position), lithium_position_(-1) { }
+  LPointerMap(Zone* zone, int position)
+      : pointer_operands_(zone, 8),
+        position_(position),
+        lithium_position_(-1) { }
 
   const ZoneList<LOperand*>* operands() const { return &pointer_operands_; }
   int position() const { return position_; }
   int lithium_position() const { return lithium_position_; }
 
   void set_lithium_position(int pos) {
     ASSERT(lithium_position_ == -1);
     lithium_position_ = pos;
   }
 
@@ skipping 14 matching lines @@
                int parameter_count,
                int argument_count,
                int value_count,
                LEnvironment* outer)
       : closure_(closure),
         arguments_stack_height_(argument_count),
         deoptimization_index_(Safepoint::kNoDeoptimizationIndex),
         translation_index_(-1),
         ast_id_(ast_id),
         parameter_count_(parameter_count),
-        values_(value_count),
-        representations_(value_count),
+        values_(closure->GetIsolate()->zone(), value_count),
+        representations_(closure->GetIsolate()->zone(), value_count),
         spilled_registers_(NULL),
         spilled_double_registers_(NULL),
         outer_(outer) {
   }
 
   Handle<JSFunction> closure() const { return closure_; }
   int arguments_stack_height() const { return arguments_stack_height_; }
   int deoptimization_index() const { return deoptimization_index_; }
   int translation_index() const { return translation_index_; }
   int ast_id() const { return ast_id_; }
@@ skipping 126 matching lines @@
   ShallowIterator current_iterator_;
 };
 
 
 int ElementsKindToShiftSize(JSObject::ElementsKind elements_kind);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_