Remove TLS access for current Zone.

src/scopes.cc

 // 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 39 matching lines @@
 
 static bool Match(void* key1, void* key2) {
   String* name1 = *reinterpret_cast<String**>(key1);
   String* name2 = *reinterpret_cast<String**>(key2);
   ASSERT(name1->IsSymbol());
   ASSERT(name2->IsSymbol());
   return name1 == name2;
 }
 
 
-VariableMap::VariableMap() : ZoneHashMap(Match, 8) {}
+VariableMap::VariableMap(Zone* zone)
+    : ZoneHashMap(Match, 8, ZoneAllocationPolicy(zone)),
+      zone_(zone) {}
 VariableMap::~VariableMap() {}
 
 
 Variable* VariableMap::Declare(
     Scope* scope,
     Handle<String> name,
     VariableMode mode,
     bool is_valid_lhs,
     Variable::Kind kind,
     InitializationFlag initialization_flag,
     Interface* interface) {
-  Entry* p = ZoneHashMap::Lookup(name.location(), name->Hash(), true);
+  Entry* p = ZoneHashMap::Lookup(name.location(), name->Hash(), true,
+                                 ZoneAllocationPolicy(zone()));
   if (p->value == NULL) {
     // The variable has not been declared yet -> insert it.
     ASSERT(p->key == name.location());
-    p->value = new Variable(scope,
-                            name,
-                            mode,
-                            is_valid_lhs,
-                            kind,
-                            initialization_flag,
-                            interface);
+    p->value = new(zone()) Variable(scope,
+                                    name,
+                                    mode,
+                                    is_valid_lhs,
+                                    kind,
+                                    initialization_flag,
+                                    interface);
   }
   return reinterpret_cast<Variable*>(p->value);
 }
 
 
 Variable* VariableMap::Lookup(Handle<String> name) {
-  Entry* p = ZoneHashMap::Lookup(name.location(), name->Hash(), false);
+  Entry* p = ZoneHashMap::Lookup(name.location(), name->Hash(), false,
+                                 ZoneAllocationPolicy(NULL));
   if (p != NULL) {
     ASSERT(*reinterpret_cast<String**>(p->key) == *name);
     ASSERT(p->value != NULL);
     return reinterpret_cast<Variable*>(p->value);
   }
   return NULL;
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
-Scope::Scope(Scope* outer_scope, ScopeType type)
+Scope::Scope(Scope* outer_scope, ScopeType type, Zone* zone)
     : isolate_(Isolate::Current()),
-      inner_scopes_(4),
-      variables_(),
-      temps_(4),
-      params_(4),
-      unresolved_(16),
-      decls_(4),
+      inner_scopes_(4, zone),
+      variables_(zone),
+      temps_(4, zone),
+      params_(4, zone),
+      unresolved_(16, zone),
+      decls_(4, zone),
       interface_(FLAG_harmony_modules &&
                  (type == MODULE_SCOPE || type == GLOBAL_SCOPE)
-                     ? Interface::NewModule() : NULL),
-      already_resolved_(false) {
+                     ? Interface::NewModule(zone) : NULL),
+      already_resolved_(false),
+      zone_(zone) {
   SetDefaults(type, outer_scope, Handle<ScopeInfo>::null());
   // At some point we might want to provide outer scopes to
   // eval scopes (by walking the stack and reading the scope info).
   // In that case, the ASSERT below needs to be adjusted.
   ASSERT_EQ(type == GLOBAL_SCOPE, outer_scope == NULL);
   ASSERT(!HasIllegalRedeclaration());
 }
 
 
 Scope::Scope(Scope* inner_scope,
              ScopeType type,
-             Handle<ScopeInfo> scope_info)
+             Handle<ScopeInfo> scope_info,
+             Zone* zone)
     : isolate_(Isolate::Current()),
-      inner_scopes_(4),
-      variables_(),
-      temps_(4),
-      params_(4),
-      unresolved_(16),
-      decls_(4),
+      inner_scopes_(4, zone),
+      variables_(zone),
+      temps_(4, zone),
+      params_(4, zone),
+      unresolved_(16, zone),
+      decls_(4, zone),
       interface_(NULL),
-      already_resolved_(true) {
+      already_resolved_(true),
+      zone_(zone) {
   SetDefaults(type, NULL, scope_info);
   if (!scope_info.is_null()) {
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
   AddInnerScope(inner_scope);
 }
 
 
-Scope::Scope(Scope* inner_scope, Handle<String> catch_variable_name)
+Scope::Scope(Scope* inner_scope, Handle<String> catch_variable_name, Zone* zone)
     : isolate_(Isolate::Current()),
-      inner_scopes_(1),
-      variables_(),
-      temps_(0),
-      params_(0),
-      unresolved_(0),
-      decls_(0),
+      inner_scopes_(1, zone),
+      variables_(zone),
+      temps_(0, zone),
+      params_(0, zone),
+      unresolved_(0, zone),
+      decls_(0, zone),
       interface_(NULL),
-      already_resolved_(true) {
+      already_resolved_(true),
+      zone_(zone) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<ScopeInfo>::null());
   AddInnerScope(inner_scope);
   ++num_var_or_const_;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           VAR,
                                           true,  // Valid left-hand side.
                                           Variable::NORMAL,
                                           kCreatedInitialized);
@@ skipping 27 matching lines @@
   scope_info_ = scope_info;
   start_position_ = RelocInfo::kNoPosition;
   end_position_ = RelocInfo::kNoPosition;
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
   }
 }
 
 
-Scope* Scope::DeserializeScopeChain(Context* context, Scope* global_scope) {
+Scope* Scope::DeserializeScopeChain(Context* context, Scope* global_scope,
+                                    Zone* zone) {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
   bool contains_with = false;
   while (!context->IsGlobalContext()) {
     if (context->IsWithContext()) {
-      Scope* with_scope = new Scope(current_scope,
-                                    WITH_SCOPE,
-                                    Handle<ScopeInfo>::null());
+      Scope* with_scope = new(zone) Scope(current_scope,
+                                          WITH_SCOPE,
+                                          Handle<ScopeInfo>::null(),
+                                          zone);
       current_scope = with_scope;
       // All the inner scopes are inside a with.
       contains_with = true;
       for (Scope* s = innermost_scope; s != NULL; s = s->outer_scope()) {
         s->scope_inside_with_ = true;
       }
     } else if (context->IsFunctionContext()) {
       ScopeInfo* scope_info = context->closure()->shared()->scope_info();
-      current_scope = new Scope(current_scope,
-                                FUNCTION_SCOPE,
-                                Handle<ScopeInfo>(scope_info));
+      current_scope = new(zone) Scope(current_scope,
+                                      FUNCTION_SCOPE,
+                                      Handle<ScopeInfo>(scope_info),
+                                      zone);
     } else if (context->IsBlockContext()) {
       ScopeInfo* scope_info = ScopeInfo::cast(context->extension());
-      current_scope = new Scope(current_scope,
-                                BLOCK_SCOPE,
-                                Handle<ScopeInfo>(scope_info));
+      current_scope = new(zone) Scope(current_scope,
+                                      BLOCK_SCOPE,
+                                      Handle<ScopeInfo>(scope_info),
+                                      zone);
     } else {
       ASSERT(context->IsCatchContext());
       String* name = String::cast(context->extension());
-      current_scope = new Scope(current_scope, Handle<String>(name));
+      current_scope = new(zone) Scope(
+          current_scope, Handle<String>(name), zone);
     }
     if (contains_with) current_scope->RecordWithStatement();
     if (innermost_scope == NULL) innermost_scope = current_scope;
 
     // Forget about a with when we move to a context for a different function.
     if (context->previous()->closure() != context->closure()) {
       contains_with = false;
     }
     context = context->previous();
   }
@@ skipping 55 matching lines @@
   info->SetScope(scope);
   return true;
 }
 
 
 void Scope::Initialize() {
   ASSERT(!already_resolved());
 
   // Add this scope as a new inner scope of the outer scope.
   if (outer_scope_ != NULL) {
-    outer_scope_->inner_scopes_.Add(this);
+    outer_scope_->inner_scopes_.Add(this, zone());
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   } else {
     scope_inside_with_ = is_with_scope();
   }
 
   // Declare convenience variables.
   // Declare and allocate receiver (even for the global scope, and even
   // if naccesses_ == 0).
   // NOTE: When loading parameters in the global scope, we must take
   // care not to access them as properties of the global object, but
@@ skipping 44 matching lines @@
     }
   }
 
   // Reparent inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     outer_scope()->AddInnerScope(inner_scopes_[i]);
   }
 
   // Move unresolved variables
   for (int i = 0; i < unresolved_.length(); i++) {
-    outer_scope()->unresolved_.Add(unresolved_[i]);
+    outer_scope()->unresolved_.Add(unresolved_[i], zone());
   }
 
   return NULL;
 }
 
 
 Variable* Scope::LocalLookup(Handle<String> name) {
   Variable* result = variables_.Lookup(name);
   if (result != NULL || scope_info_.is_null()) {
     return result;
@@ skipping 10 matching lines @@
   if (index < 0) {
     // Check parameters.
     index = scope_info_->ParameterIndex(*name);
     if (index < 0) return NULL;
 
     mode = DYNAMIC;
     location = Variable::LOOKUP;
     init_flag = kCreatedInitialized;
   }
 
-  Variable* var =
-      variables_.Declare(this,
-                         name,
-                         mode,
-                         true,
-                         Variable::NORMAL,
-                         init_flag);
+  Variable* var = variables_.Declare(this, name, mode, true, Variable::NORMAL,
+                                     init_flag);
   var->AllocateTo(location, index);
   return var;
 }
 
 
 Variable* Scope::LookupFunctionVar(Handle<String> name,
                                    AstNodeFactory<AstNullVisitor>* factory) {
   if (function_ != NULL && function_->proxy()->name().is_identical_to(name)) {
     return function_->proxy()->var();
   } else if (!scope_info_.is_null()) {
     // If we are backed by a scope info, try to lookup the variable there.
     VariableMode mode;
     int index = scope_info_->FunctionContextSlotIndex(*name, &mode);
     if (index < 0) return NULL;
-    Variable* var = new Variable(
+    Variable* var = new(zone()) Variable(
         this, name, mode, true /* is valid LHS */,
         Variable::NORMAL, kCreatedInitialized);
     VariableProxy* proxy = factory->NewVariableProxy(var);
     VariableDeclaration* declaration =
         factory->NewVariableDeclaration(proxy, mode, this);
     DeclareFunctionVar(declaration);
     var->AllocateTo(Variable::CONTEXT, index);
     return var;
   } else {
     return NULL;
   }
 }
 
 
 Variable* Scope::Lookup(Handle<String> name) {
   for (Scope* scope = this;
        scope != NULL;
        scope = scope->outer_scope()) {
     Variable* var = scope->LocalLookup(name);
     if (var != NULL) return var;
   }
   return NULL;
 }
 
 
 void Scope::DeclareParameter(Handle<String> name, VariableMode mode) {
   ASSERT(!already_resolved());
   ASSERT(is_function_scope());
-  Variable* var = variables_.Declare(
-      this, name, mode, true, Variable::NORMAL, kCreatedInitialized);
-  params_.Add(var);
+  Variable* var = variables_.Declare(this, name, mode, true, Variable::NORMAL,
+                                     kCreatedInitialized);
+  params_.Add(var, zone());
 }
 
 
 Variable* Scope::DeclareLocal(Handle<String> name,
                               VariableMode mode,
                               InitializationFlag init_flag,
                               Interface* interface) {
   ASSERT(!already_resolved());
   // This function handles VAR and CONST modes.  DYNAMIC variables are
   // introduces during variable allocation, INTERNAL variables are allocated
@@ skipping 26 matching lines @@
     if (unresolved_[i] == var) {
       unresolved_.Remove(i);
       return;
     }
   }
 }
 
 
 Variable* Scope::NewTemporary(Handle<String> name) {
   ASSERT(!already_resolved());
-  Variable* var = new Variable(this,
-                               name,
-                               TEMPORARY,
-                               true,
-                               Variable::NORMAL,
-                               kCreatedInitialized);
-  temps_.Add(var);
+  Variable* var = new(zone()) Variable(this,
+                                       name,
+                                       TEMPORARY,
+                                       true,
+                                       Variable::NORMAL,
+                                       kCreatedInitialized);
+  temps_.Add(var, zone());
   return var;
 }
 
 
 void Scope::AddDeclaration(Declaration* declaration) {
-  decls_.Add(declaration);
+  decls_.Add(declaration, zone());
 }
 
 
 void Scope::SetIllegalRedeclaration(Expression* expression) {
   // Record only the first illegal redeclaration.
   if (!HasIllegalRedeclaration()) {
     illegal_redecl_ = expression;
   }
   ASSERT(HasIllegalRedeclaration());
 }
@@ skipping 55 matching lines @@
 void Scope::CollectStackAndContextLocals(ZoneList<Variable*>* stack_locals,
                                          ZoneList<Variable*>* context_locals) {
   ASSERT(stack_locals != NULL);
   ASSERT(context_locals != NULL);
 
   // Collect temporaries which are always allocated on the stack.
   for (int i = 0; i < temps_.length(); i++) {
     Variable* var = temps_[i];
     if (var->is_used()) {
       ASSERT(var->IsStackLocal());
-      stack_locals->Add(var);
+      stack_locals->Add(var, zone());
     }
   }
 
   // Collect declared local variables.
   for (VariableMap::Entry* p = variables_.Start();
        p != NULL;
        p = variables_.Next(p)) {
     Variable* var = reinterpret_cast<Variable*>(p->value);
     if (var->is_used()) {
       if (var->IsStackLocal()) {
-        stack_locals->Add(var);
+        stack_locals->Add(var, zone());
       } else if (var->IsContextSlot()) {
-        context_locals->Add(var);
+        context_locals->Add(var, zone());
       }
     }
   }
 }
 
 
 bool Scope::AllocateVariables(CompilationInfo* info,
                               AstNodeFactory<AstNullVisitor>* factory) {
   // 1) Propagate scope information.
   bool outer_scope_calls_non_strict_eval = false;
@@ skipping 77 matching lines @@
   Scope* scope = this;
   while (!scope->is_declaration_scope()) {
     scope = scope->outer_scope();
   }
   return scope;
 }
 
 
 Handle<ScopeInfo> Scope::GetScopeInfo() {
   if (scope_info_.is_null()) {
-    scope_info_ = ScopeInfo::Create(this);
+    scope_info_ = ScopeInfo::Create(this, zone());
   }
   return scope_info_;
 }
 
 
 void Scope::GetNestedScopeChain(
     List<Handle<ScopeInfo> >* chain,
     int position) {
   if (!is_eval_scope()) chain->Add(Handle<ScopeInfo>(GetScopeInfo()));
 
@@ skipping 165 matching lines @@
       inner_scopes_[i]->Print(n1);
     }
   }
 
   Indent(n0, "}\n");
 }
 #endif  // DEBUG
 
 
 Variable* Scope::NonLocal(Handle<String> name, VariableMode mode) {
-  if (dynamics_ == NULL) dynamics_ = new DynamicScopePart();
+  if (dynamics_ == NULL) dynamics_ = new(zone()) DynamicScopePart(zone());
   VariableMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
     InitializationFlag init_flag = (mode == VAR)
         ? kCreatedInitialized : kNeedsInitialization;
     var = map->Declare(NULL,
                        name,
                        mode,
                        true,
@@ skipping 113 matching lines @@
 
   ASSERT(var != NULL);
   proxy->BindTo(var);
 
   if (FLAG_harmony_modules) {
     bool ok;
 #ifdef DEBUG
     if (FLAG_print_interface_details)
       PrintF("# Resolve %s:\n", var->name()->ToAsciiArray());
 #endif
-    proxy->interface()->Unify(var->interface(), &ok);
+    proxy->interface()->Unify(var->interface(), zone(), &ok);
     if (!ok) {
 #ifdef DEBUG
       if (FLAG_print_interfaces) {
         PrintF("SCOPES TYPE ERROR\n");
         PrintF("proxy: ");
         proxy->interface()->Print();
         PrintF("var: ");
         var->interface()->Print();
       }
 #endif
@@ skipping 251 matching lines @@
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 
 } }  // namespace v8::internal