Remove TLS access for current Zone.

src/hydrogen.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 59 matching lines @@
   HLoopInformation* loop_information() const { return loop_information_; }
   const ZoneList<HBasicBlock*>* predecessors() const { return &predecessors_; }
   bool HasPredecessor() const { return predecessors_.length() > 0; }
   const ZoneList<HBasicBlock*>* dominated_blocks() const {
     return &dominated_blocks_;
   }
   const ZoneList<int>* deleted_phis() const {
     return &deleted_phis_;
   }
   void RecordDeletedPhi(int merge_index) {
-    deleted_phis_.Add(merge_index);
+    deleted_phis_.Add(merge_index, zone());
   }
   HBasicBlock* dominator() const { return dominator_; }
   HEnvironment* last_environment() const { return last_environment_; }
   int argument_count() const { return argument_count_; }
   void set_argument_count(int count) { argument_count_ = count; }
   int first_instruction_index() const { return first_instruction_index_; }
   void set_first_instruction_index(int index) {
     first_instruction_index_ = index;
   }
   int last_instruction_index() const { return last_instruction_index_; }
@@ skipping 114 matching lines @@
   void Advance() { current_++; }
 
  private:
   const ZoneList<HBasicBlock*>* predecessor_list_;
   int current_;
 };
 
 
 class HLoopInformation: public ZoneObject {
  public:
-  explicit HLoopInformation(HBasicBlock* loop_header)
-      : back_edges_(4),
+  HLoopInformation(HBasicBlock* loop_header, Zone* zone)
+      : back_edges_(4, zone),
         loop_header_(loop_header),
-        blocks_(8),
+        blocks_(8, zone),
         stack_check_(NULL) {
-    blocks_.Add(loop_header);
+    blocks_.Add(loop_header, zone);
   }
   virtual ~HLoopInformation() {}
 
   const ZoneList<HBasicBlock*>* back_edges() const { return &back_edges_; }
   const ZoneList<HBasicBlock*>* blocks() const { return &blocks_; }
   HBasicBlock* loop_header() const { return loop_header_; }
   HBasicBlock* GetLastBackEdge() const;
   void RegisterBackEdge(HBasicBlock* block);
 
   HStackCheck* stack_check() const { return stack_check_; }
   void set_stack_check(HStackCheck* stack_check) {
     stack_check_ = stack_check;
   }
 
  private:
   void AddBlock(HBasicBlock* block);
 
   ZoneList<HBasicBlock*> back_edges_;
   HBasicBlock* loop_header_;
   ZoneList<HBasicBlock*> blocks_;
   HStackCheck* stack_check_;
 };
 
 class BoundsCheckTable;
 class HGraph: public ZoneObject {
  public:
-  explicit HGraph(CompilationInfo* info);
+  HGraph(CompilationInfo* info, Zone* zone);
 
   Isolate* isolate() { return isolate_; }
-  Zone* zone() { return isolate_->zone(); }
+  Zone* zone() const { return zone_; }
 
   const ZoneList<HBasicBlock*>* blocks() const { return &blocks_; }
   const ZoneList<HPhi*>* phi_list() const { return phi_list_; }
   HBasicBlock* entry_block() const { return entry_block_; }
   HEnvironment* start_environment() const { return start_environment_; }
 
   void InitializeInferredTypes();
   void InsertTypeConversions();
   void InsertRepresentationChanges();
   void MarkDeoptimizeOnUndefined();
@@ skipping 36 matching lines @@
     return arguments_object_.get();
   }
 
   void SetArgumentsObject(HArgumentsObject* object) {
     arguments_object_.set(object);
   }
 
   int GetMaximumValueID() const { return values_.length(); }
   int GetNextBlockID() { return next_block_id_++; }
   int GetNextValueID(HValue* value) {
-    values_.Add(value);
+    values_.Add(value, zone());
     return values_.length() - 1;
   }
   HValue* LookupValue(int id) const {
     if (id >= 0 && id < values_.length()) return values_[id];
     return NULL;
   }
 
 #ifdef DEBUG
   void Verify(bool do_full_verify) const;
 #endif
@@ skipping 55 matching lines @@
   SetOncePointer<HConstant> constant_1_;
   SetOncePointer<HConstant> constant_minus1_;
   SetOncePointer<HConstant> constant_true_;
   SetOncePointer<HConstant> constant_false_;
   SetOncePointer<HConstant> constant_hole_;
   SetOncePointer<HArgumentsObject> arguments_object_;
 
   SetOncePointer<HBasicBlock> osr_loop_entry_;
   SetOncePointer<ZoneList<HUnknownOSRValue*> > osr_values_;
 
+  Zone* zone_;
+
   DISALLOW_COPY_AND_ASSIGN(HGraph);
 };
 
 
 Zone* HBasicBlock::zone() { return graph_->zone(); }
 
 
 // Type of stack frame an environment might refer to.
 enum FrameType { JS_FUNCTION, JS_CONSTRUCT, ARGUMENTS_ADAPTOR };
 
 
 class HEnvironment: public ZoneObject {
  public:
   HEnvironment(HEnvironment* outer,
                Scope* scope,
-               Handle<JSFunction> closure);
+               Handle<JSFunction> closure,
+               Zone* zone);
 
   HEnvironment* DiscardInlined(bool drop_extra) {
     HEnvironment* outer = outer_;
     while (outer->frame_type() != JS_FUNCTION) outer = outer->outer_;
     if (drop_extra) outer->Drop(1);
     return outer;
   }
 
   HEnvironment* arguments_environment() {
     return outer()->frame_type() == ARGUMENTS_ADAPTOR ? outer() : this;
@@ skipping 46 matching lines @@
   }
 
   HValue* LookupContext() const {
     // Return first special.
     return Lookup(parameter_count());
   }
 
   void Push(HValue* value) {
     ASSERT(value != NULL);
     ++push_count_;
-    values_.Add(value);
+    values_.Add(value, zone());
   }
 
   HValue* Pop() {
     ASSERT(!ExpressionStackIsEmpty());
     if (push_count_ > 0) {
       --push_count_;
     } else {
       ++pop_count_;
     }
     return values_.RemoveLast();
@@ skipping 36 matching lines @@
   }
 
   void SetValueAt(int index, HValue* value) {
     ASSERT(index < length());
     values_[index] = value;
   }
 
   void PrintTo(StringStream* stream);
   void PrintToStd();
 
+  Zone* zone() const { return zone_; }
+
  private:
-  explicit HEnvironment(const HEnvironment* other);
+  HEnvironment(const HEnvironment* other, Zone* zone);
 
   HEnvironment(HEnvironment* outer,
                Handle<JSFunction> closure,
                FrameType frame_type,
-               int arguments);
+               int arguments,
+               Zone* zone);
 
   // Create an artificial stub environment (e.g. for argument adaptor or
   // constructor stub).
   HEnvironment* CreateStubEnvironment(HEnvironment* outer,
                                       Handle<JSFunction> target,
                                       FrameType frame_type,
                                       int arguments) const;
 
   // True if index is included in the expression stack part of the environment.
   bool HasExpressionAt(int index) const;
@@ skipping 17 matching lines @@
   ZoneList<HValue*> values_;
   ZoneList<int> assigned_variables_;
   FrameType frame_type_;
   int parameter_count_;
   int specials_count_;
   int local_count_;
   HEnvironment* outer_;
   int pop_count_;
   int push_count_;
   int ast_id_;
+  Zone* zone_;
 };
 
 
 class HGraphBuilder;
 
 enum ArgumentsAllowedFlag {
   ARGUMENTS_NOT_ALLOWED,
   ARGUMENTS_ALLOWED
 };
 
@@ skipping 24 matching lines @@
 
   void set_for_typeof(bool for_typeof) { for_typeof_ = for_typeof; }
   bool is_for_typeof() { return for_typeof_; }
 
  protected:
   AstContext(HGraphBuilder* owner, Expression::Context kind);
   virtual ~AstContext();
 
   HGraphBuilder* owner() const { return owner_; }
 
-  inline Zone* zone();
+  inline Zone* zone() const;

[danno, 2012/06/05 13:42:35]

Why the const here and not on other version of zone() on other objects?

[sanjoy, 2012/06/05 14:21:39]

Fixed.  Changed all the zone() methods (except the one in Isolate) to const.

 
   // We want to be able to assert, in a context-specific way, that the stack
   // height makes sense when the context is filled.
 #ifdef DEBUG
   int original_length_;
 #endif
 
  private:
   HGraphBuilder* owner_;
   Expression::Context kind_;
@@ skipping 193 matching lines @@
 
     // Search the break stack for a break or continue target.
     HBasicBlock* Get(BreakableStatement* stmt, BreakType type, int* drop_extra);
 
    private:
     BreakAndContinueInfo* info_;
     HGraphBuilder* owner_;
     BreakAndContinueScope* next_;
   };
 
-  HGraphBuilder(CompilationInfo* info, TypeFeedbackOracle* oracle);
+  HGraphBuilder(CompilationInfo* info, TypeFeedbackOracle* oracle, Zone* zone);
 
   HGraph* CreateGraph();
 
   // Simple accessors.
   HGraph* graph() const { return graph_; }
   BreakAndContinueScope* break_scope() const { return break_scope_; }
   void set_break_scope(BreakAndContinueScope* head) { break_scope_ = head; }
 
   HBasicBlock* current_block() const { return current_block_; }
   void set_current_block(HBasicBlock* block) { current_block_ = block; }
@@ skipping 302 matching lines @@
                                        HValue* key,
                                        HValue* value);
 
   HValue* BuildContextChainWalk(Variable* var);
 
   void AddCheckConstantFunction(Call* expr,
                                 HValue* receiver,
                                 Handle<Map> receiver_map,
                                 bool smi_and_map_check);
 
-  Zone* zone() { return zone_; }
+  Zone* zone() const { return zone_; }

[danno, 2012/06/05 13:42:35]

Why the const here and not on other version of zone() on other objects?

 
   // The translation state of the currently-being-translated function.
   FunctionState* function_state_;
 
   // The base of the function state stack.
   FunctionState initial_function_state_;
 
   // Expression context of the currently visited subexpression. NULL when
   // visiting statements.
   AstContext* ast_context_;
@@ skipping 11 matching lines @@
 
   bool inline_bailout_;
 
   friend class FunctionState;  // Pushes and pops the state stack.
   friend class AstContext;  // Pushes and pops the AST context stack.
 
   DISALLOW_COPY_AND_ASSIGN(HGraphBuilder);
 };
 
 
-Zone* AstContext::zone() { return owner_->zone(); }
+Zone* AstContext::zone() const { return owner_->zone(); }

[danno, 2012/06/05 13:42:35]

Why the const here and not on other version of zone() on other objects?

 
 
 class HValueMap: public ZoneObject {
  public:
-  HValueMap()
+  explicit HValueMap(Zone* zone)
       : array_size_(0),
         lists_size_(0),
         count_(0),
         present_flags_(0),
         array_(NULL),
         lists_(NULL),
         free_list_head_(kNil) {
-    ResizeLists(kInitialSize);
-    Resize(kInitialSize);
+    ResizeLists(kInitialSize, zone);
+    Resize(kInitialSize, zone);
   }
 
   void Kill(GVNFlagSet flags);
 
-  void Add(HValue* value) {
+  void Add(HValue* value, Zone* zone) {
     present_flags_.Add(value->gvn_flags());
-    Insert(value);
+    Insert(value, zone);
   }
 
   HValue* Lookup(HValue* value) const;
 
   HValueMap* Copy(Zone* zone) const {
     return new(zone) HValueMap(zone, this);
   }
 
   bool IsEmpty() const { return count_ == 0; }
 
  private:
   // A linked list of HValue* values.  Stored in arrays.
   struct HValueMapListElement {
     HValue* value;
     int next;  // Index in the array of the next list element.
   };
   static const int kNil = -1;  // The end of a linked list
 
   // Must be a power of 2.
   static const int kInitialSize = 16;
 
   HValueMap(Zone* zone, const HValueMap* other);
 
-  void Resize(int new_size);
-  void ResizeLists(int new_size);
-  void Insert(HValue* value);
+  void Resize(int new_size, Zone* zone);
+  void ResizeLists(int new_size, Zone* zone);
+  void Insert(HValue* value, Zone* zone);
   uint32_t Bound(uint32_t value) const { return value & (array_size_ - 1); }
 
   int array_size_;
   int lists_size_;
   int count_;  // The number of values stored in the HValueMap.
   GVNFlagSet present_flags_;  // All flags that are in any value in the
                               // HValueMap.
   HValueMapListElement* array_;  // Primary store - contains the first value
   // with a given hash.  Colliding elements are stored in linked lists.
   HValueMapListElement* lists_;  // The linked lists containing hash collisions.
@@ skipping 132 matching lines @@
    private:
     HTracer* tracer_;
     const char* name_;
   };
 
   explicit HTracer(const char* filename)
       : filename_(filename), trace_(&string_allocator_), indent_(0) {
     WriteChars(filename, "", 0, false);
   }
 
-  void TraceLiveRange(LiveRange* range, const char* type);
+  void TraceLiveRange(LiveRange* range, const char* type, Zone* zone);
   void Trace(const char* name, HGraph* graph, LChunk* chunk);
   void FlushToFile();
 
   void PrintEmptyProperty(const char* name) {
     PrintIndent();
     trace_.Add("%s\n", name);
   }
 
   void PrintStringProperty(const char* name, const char* value) {
     PrintIndent();
@@ skipping 24 matching lines @@
   const char* filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_