Refactor allocation policies.

src/scopes.cc

 // 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 98 matching lines @@
   return NULL;
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 
 // Dummy constructor
 Scope::Scope(Type type)
-  : inner_scopes_(0),
-    variables_(false),
-    temps_(0),
-    params_(0),
-    unresolved_(0),
-    decls_(0),
-    already_resolved_(false) {
+    : inner_scopes_(ZONE, 0),
+      variables_(false),
+      temps_(ZONE, 0),
+      params_(ZONE, 0),
+      unresolved_(ZONE, 0),
+      decls_(ZONE, 0),
+      already_resolved_(false) {
   SetDefaults(type, NULL, Handle<SerializedScopeInfo>::null());
 }
 
 
 Scope::Scope(Scope* outer_scope, Type type)
-  : inner_scopes_(4),
-    variables_(),
-    temps_(4),
-    params_(4),
-    unresolved_(16),
-    decls_(4),
-    already_resolved_(false) {
+    : inner_scopes_(ZONE, 4),
+      variables_(),
+      temps_(ZONE, 4),
+      params_(ZONE, 4),
+      unresolved_(ZONE, 16),
+      decls_(ZONE, 4),
+      already_resolved_(false) {
   SetDefaults(type, outer_scope, Handle<SerializedScopeInfo>::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((type == GLOBAL_SCOPE || type == EVAL_SCOPE) == (outer_scope == NULL));
   ASSERT(!HasIllegalRedeclaration());
 }
 
 
 Scope::Scope(Scope* inner_scope, Handle<SerializedScopeInfo> scope_info)
-  : inner_scopes_(4),
-    variables_(),
-    temps_(4),
-    params_(4),
-    unresolved_(16),
-    decls_(4),
-    already_resolved_(true) {
+    : inner_scopes_(ZONE, 4),
+      variables_(),
+      temps_(ZONE, 4),
+      params_(ZONE, 4),
+      unresolved_(ZONE, 16),
+      decls_(ZONE, 4),
+      already_resolved_(true) {
   ASSERT(!scope_info.is_null());
   SetDefaults(FUNCTION_SCOPE, NULL, scope_info);
   if (scope_info->HasHeapAllocatedLocals()) {
     num_heap_slots_ = scope_info_->NumberOfContextSlots();
   }
   AddInnerScope(inner_scope);
 }
 
 
 Scope::Scope(Scope* inner_scope, Handle<String> catch_variable_name)
-    : inner_scopes_(1),
+    : inner_scopes_(ZONE, 1),
       variables_(),
-      temps_(0),
-      params_(0),
-      unresolved_(0),
-      decls_(0),
+      temps_(ZONE, 0),
+      params_(ZONE, 0),
+      unresolved_(ZONE, 0),
+      decls_(ZONE, 0),
       already_resolved_(true) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<SerializedScopeInfo>::null());
   AddInnerScope(inner_scope);
   ++num_var_or_const_;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           Variable::VAR,
                                           true,  // Valid left-hand side.
                                           Variable::NORMAL);
   AllocateHeapSlot(variable);
@@ skipping 281 matching lines @@
     Variable* var = reinterpret_cast<Variable*>(p->value);
     if (var->is_used()) {
       locals->Add(var);
     }
   }
 }
 
 
 // Make sure the method gets instantiated by the template system.
 template void Scope::CollectUsedVariables(
-    List<Variable*, FreeStoreAllocationPolicy>* locals);
+    List<Variable*, FreeStoreAllocator>* locals);
 template void Scope::CollectUsedVariables(
-    List<Variable*, PreallocatedStorage>* locals);
+    List<Variable*, PreallocatedStorageAllocator>* locals);
 template void Scope::CollectUsedVariables(
-    List<Variable*, ZoneListAllocationPolicy>* locals);
+    List<Variable*, ZoneListAllocator>* locals);
 
 
 void Scope::AllocateVariables(Handle<Context> context) {
   ASSERT(outer_scope_ == NULL);  // eval or global scopes only
 
   // 1) Propagate scope information.
   // If we are in an eval scope, we may have other outer scopes about
   // which we don't know anything at this point. Thus we must be conservative
   // and assume they may invoke eval themselves. Eventually we could capture
   // this information in the ScopeInfo and then use it here (by traversing
@@ skipping 603 matching lines @@
   if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS &&
       !must_have_local_context) {
     num_heap_slots_ = 0;
   }
 
   // Allocation done.
   ASSERT(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }
 
 } }  // namespace v8::internal