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)) {}
 VariableMap::~VariableMap() {}
 
 
 Variable* VariableMap::Declare(
     Scope* scope,
     Handle<String> name,
     VariableMode mode,
     bool is_valid_lhs,
     Variable::Kind kind,
     InitializationFlag initialization_flag,
+    Zone* zone,
     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);
+                                          kCreatedInitialized,
+                                          zone);
   AllocateHeapSlot(variable);
 }
 
 
 void Scope::SetDefaults(ScopeType type,
                         Scope* outer_scope,
                         Handle<ScopeInfo> scope_info) {
   outer_scope_ = outer_scope;
   type_ = type;
   scope_name_ = isolate_->factory()->empty_symbol();
@@ skipping 17 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
   // instead load them directly from the stack. Currently, the only
   // such parameter is 'this' which is passed on the stack when
   // invoking scripts
   if (is_declaration_scope()) {
     Variable* var =
         variables_.Declare(this,
                            isolate_->factory()->this_symbol(),
                            VAR,
                            false,
                            Variable::THIS,
-                           kCreatedInitialized);
+                           kCreatedInitialized,
+                           zone());
     var->AllocateTo(Variable::PARAMETER, -1);
     receiver_ = var;
   } else {
     ASSERT(outer_scope() != NULL);
     receiver_ = outer_scope()->receiver();
   }
 
   if (is_function_scope()) {
     // Declare 'arguments' variable which exists in all functions.
     // Note that it might never be accessed, in which case it won't be
     // allocated during variable allocation.
     variables_.Declare(this,
                        isolate_->factory()->arguments_symbol(),
                        VAR,
                        true,
                        Variable::ARGUMENTS,
-                       kCreatedInitialized);
+                       kCreatedInitialized,
+                       zone());
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   ASSERT(is_block_scope());
   ASSERT(temps_.is_empty());
   ASSERT(params_.is_empty());
 
   if (num_var_or_const() > 0) return this;
 
   // Remove this scope from outer scope.
   for (int i = 0; i < outer_scope_->inner_scopes_.length(); i++) {
     if (outer_scope_->inner_scopes_[i] == this) {
       outer_scope_->inner_scopes_.Remove(i);
       break;
     }
   }
 
   // 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 16 matching lines @@
     location = Variable::LOOKUP;
     init_flag = kCreatedInitialized;
   }
 
   Variable* var =
       variables_.Declare(this,
                          name,
                          mode,
                          true,
                          Variable::NORMAL,
-                         init_flag);
+                         init_flag,
+                         zone());
   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);
+      this, name, mode, true, Variable::NORMAL, kCreatedInitialized, zone());
+  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
   // explicitly, and TEMPORARY variables are allocated via NewTemporary().
   ASSERT(mode == VAR ||
          mode == CONST ||
          mode == CONST_HARMONY ||
          mode == LET);
   ++num_var_or_const_;
   return variables_.Declare(
-      this, name, mode, true, Variable::NORMAL, init_flag, interface);
+      this, name, mode, true, Variable::NORMAL, init_flag, zone(), interface);
 }
 
 
 Variable* Scope::DeclareGlobal(Handle<String> name) {
   ASSERT(is_global_scope());
   return variables_.Declare(this,
                             name,
                             DYNAMIC_GLOBAL,
                             true,
                             Variable::NORMAL,
-                            kCreatedInitialized);
+                            kCreatedInitialized,
+                            zone());
 }
 
 
 void Scope::RemoveUnresolved(VariableProxy* var) {
   // Most likely (always?) any variable we want to remove
   // was just added before, so we search backwards.
   for (int i = unresolved_.length(); i-- > 0;) {
     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,
                        Variable::NORMAL,
-                       init_flag);
+                       init_flag,
+                       zone());
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(Variable::LOOKUP, -1);
   }
   return var;
 }
 
 
 Variable* Scope::LookupRecursive(Handle<String> name,
                                  BindingKind* binding_kind,
                                  AstNodeFactory<AstNullVisitor>* factory) {
@@ skipping 101 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(), &ok, zone());
     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