Remove TLS access for current Zone.

src/lithium.h

 // Copyright 2012 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 169 matching lines @@
   }
 
   int virtual_register() const {
     return VirtualRegisterField::decode(value_);
   }
 
   void set_virtual_register(unsigned id) {
     value_ = VirtualRegisterField::update(value_, id);
   }
 
-  LUnallocated* CopyUnconstrained() {
-    LUnallocated* result = new LUnallocated(ANY);
+  LUnallocated* CopyUnconstrained(Zone* zone) {
+    LUnallocated* result = new(zone) LUnallocated(ANY);
     result->set_virtual_register(virtual_register());
     return result;
   }
 
   static LUnallocated* cast(LOperand* op) {
     ASSERT(op->IsUnallocated());
     return reinterpret_cast<LUnallocated*>(op);
   }
 
   bool IsUsedAtStart() {
@@ skipping 51 matching lines @@
   }
 
  private:
   LOperand* source_;
   LOperand* destination_;
 };
 
 
 class LConstantOperand: public LOperand {
  public:
-  static LConstantOperand* Create(int index) {
+  static LConstantOperand* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
-    return new LConstantOperand(index);
+    return new(zone) LConstantOperand(index);
   }
 
   static LConstantOperand* cast(LOperand* op) {
     ASSERT(op->IsConstantOperand());
     return reinterpret_cast<LConstantOperand*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
@@ skipping 12 matching lines @@
 
   static LArgument* cast(LOperand* op) {
     ASSERT(op->IsArgument());
     return reinterpret_cast<LArgument*>(op);
   }
 };
 
 
 class LStackSlot: public LOperand {
  public:
-  static LStackSlot* Create(int index) {
+  static LStackSlot* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
-    return new LStackSlot(index);
+    return new(zone) LStackSlot(index);
   }
 
   static LStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LStackSlot*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 128;
   static LStackSlot* cache;
 
   LStackSlot() : LOperand() { }
   explicit LStackSlot(int index) : LOperand(STACK_SLOT, index) { }
 };
 
 
 class LDoubleStackSlot: public LOperand {
  public:
-  static LDoubleStackSlot* Create(int index) {
+  static LDoubleStackSlot* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
-    return new LDoubleStackSlot(index);
+    return new(zone) LDoubleStackSlot(index);
   }
 
   static LDoubleStackSlot* cast(LOperand* op) {
     ASSERT(op->IsStackSlot());
     return reinterpret_cast<LDoubleStackSlot*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 128;
   static LDoubleStackSlot* cache;
 
   LDoubleStackSlot() : LOperand() { }
   explicit LDoubleStackSlot(int index) : LOperand(DOUBLE_STACK_SLOT, index) { }
 };
 
 
 class LRegister: public LOperand {
  public:
-  static LRegister* Create(int index) {
+  static LRegister* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
-    return new LRegister(index);
+    return new(zone) LRegister(index);
   }
 
   static LRegister* cast(LOperand* op) {
     ASSERT(op->IsRegister());
     return reinterpret_cast<LRegister*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   static const int kNumCachedOperands = 16;
   static LRegister* cache;
 
   LRegister() : LOperand() { }
   explicit LRegister(int index) : LOperand(REGISTER, index) { }
 };
 
 
 class LDoubleRegister: public LOperand {
  public:
-  static LDoubleRegister* Create(int index) {
+  static LDoubleRegister* Create(int index, Zone* zone) {
     ASSERT(index >= 0);
     if (index < kNumCachedOperands) return &cache[index];
-    return new LDoubleRegister(index);
+    return new(zone) LDoubleRegister(index);
   }
 
   static LDoubleRegister* cast(LOperand* op) {
     ASSERT(op->IsDoubleRegister());
     return reinterpret_cast<LDoubleRegister*>(op);
   }
 
   static void SetUpCache();
   static void TearDownCache();
 
  private:
   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_(4, zone) { }
 
-  void AddMove(LOperand* from, LOperand* to) {
-    move_operands_.Add(LMoveOperands(from, to));
+  void AddMove(LOperand* from, LOperand* to, Zone* zone) {
+    move_operands_.Add(LMoveOperands(from, to), zone);
   }
 
   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),
-        untagged_operands_(0),
+  explicit LPointerMap(int position, Zone* zone)
+      : pointer_operands_(8, zone),
+        untagged_operands_(0, zone),
         position_(position),
         lithium_position_(-1) { }
 
   const ZoneList<LOperand*>* GetNormalizedOperands() {
     for (int i = 0; i < untagged_operands_.length(); ++i) {
       RemovePointer(untagged_operands_[i]);
     }
     untagged_operands_.Clear();
     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;
   }
 
-  void RecordPointer(LOperand* op);
+  void RecordPointer(LOperand* op, Zone* zone);
   void RemovePointer(LOperand* op);
-  void RecordUntagged(LOperand* op);
+  void RecordUntagged(LOperand* op, Zone* zone);
   void PrintTo(StringStream* stream);
 
  private:
   ZoneList<LOperand*> pointer_operands_;
   ZoneList<LOperand*> untagged_operands_;
   int position_;
   int lithium_position_;
 };
 
 
 class LEnvironment: public ZoneObject {
  public:
   LEnvironment(Handle<JSFunction> closure,
                FrameType frame_type,
                int ast_id,
                int parameter_count,
                int argument_count,
                int value_count,
                LEnvironment* outer,
                Zone* zone)
       : closure_(closure),
         frame_type_(frame_type),
         arguments_stack_height_(argument_count),
         deoptimization_index_(Safepoint::kNoDeoptimizationIndex),
         translation_index_(-1),
         ast_id_(ast_id),
         parameter_count_(parameter_count),
         pc_offset_(-1),
-        values_(value_count),
+        values_(value_count, zone),
         is_tagged_(value_count, closure->GetHeap()->isolate()->zone()),
         spilled_registers_(NULL),
         spilled_double_registers_(NULL),
         outer_(outer),
         zone_(zone) { }
 
   Handle<JSFunction> closure() const { return closure_; }
   FrameType frame_type() const { return frame_type_; }
   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_; }
   int parameter_count() const { return parameter_count_; }
   int pc_offset() const { return pc_offset_; }
   LOperand** spilled_registers() const { return spilled_registers_; }
   LOperand** spilled_double_registers() const {
     return spilled_double_registers_;
   }
   const ZoneList<LOperand*>* values() const { return &values_; }
   LEnvironment* outer() const { return outer_; }
 
   void AddValue(LOperand* operand, Representation representation) {
-    values_.Add(operand);
+    values_.Add(operand, zone());
     if (representation.IsTagged()) {
       is_tagged_.Add(values_.length() - 1);
     }
   }
 
   bool HasTaggedValueAt(int index) const {
     return is_tagged_.Contains(index);
   }
 
   void Register(int deoptimization_index,
                 int translation_index,
                 int pc_offset) {
     ASSERT(!HasBeenRegistered());
     deoptimization_index_ = deoptimization_index;
     translation_index_ = translation_index;
     pc_offset_ = pc_offset;
   }
   bool HasBeenRegistered() const {
     return deoptimization_index_ != Safepoint::kNoDeoptimizationIndex;
   }
 
   void SetSpilledRegisters(LOperand** registers,
                            LOperand** double_registers) {
     spilled_registers_ = registers;
     spilled_double_registers_ = double_registers;
   }
 
   void PrintTo(StringStream* stream);
 
-  Zone* zone() { return zone_; }
+  Zone* zone() const { return zone_; }
 
  private:
   Handle<JSFunction> closure_;
   FrameType frame_type_;
   int arguments_stack_height_;
   int deoptimization_index_;
   int translation_index_;
   int ast_id_;
   int parameter_count_;
   int pc_offset_;
@@ skipping 85 matching lines @@
   ShallowIterator current_iterator_;
 };
 
 
 int ElementsKindToShiftSize(ElementsKind elements_kind);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_