Refactor allocation policies.

src/scopeinfo.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 33 matching lines @@
   // We may have rewritten parameters (that are in the arguments object)
   // and which may have a NULL slot... - find a better solution...
   int x = (s != NULL ? s->index() : 0);
   int y = (t != NULL ? t->index() : 0);
   // Consider sorting them according to type as well?
   return x - y;
 }
 
 
 template<class Allocator>
-ScopeInfo<Allocator>::ScopeInfo(Scope* scope)
+ScopeInfo<Allocator>::ScopeInfo(Scope* scope, const Allocator& allocator)
     : function_name_(FACTORY->empty_symbol()),
       calls_eval_(scope->calls_eval()),
       is_strict_mode_(scope->is_strict_mode()),
-      parameters_(scope->num_parameters()),
-      stack_slots_(scope->num_stack_slots()),
-      context_slots_(scope->num_heap_slots()),
-      context_modes_(scope->num_heap_slots()) {
+      parameters_(scope->num_parameters(), allocator),
+      stack_slots_(scope->num_stack_slots(), allocator),
+      context_slots_(scope->num_heap_slots(), allocator),
+      context_modes_(scope->num_heap_slots(), allocator) {
   // Add parameters.
   for (int i = 0; i < scope->num_parameters(); i++) {
     ASSERT(parameters_.length() == i);
     parameters_.Add(scope->parameter(i)->name());
   }
 
   // Add stack locals and collect heap locals.
   // We are assuming that the locals' slots are allocated in
   // increasing order, so we can simply add them to the
   // ScopeInfo lists. However, due to usage analysis, this is
   // not true for context-allocated locals: Some of them
   // may be parameters which are allocated before the
   // non-parameter locals. When the non-parameter locals are
   // sorted according to usage, the allocated slot indices may
   // not be in increasing order with the variable list anymore.
   // Thus, we first collect the context-allocated locals, and then
   // sort them by context slot index before adding them to the
   // ScopeInfo list.
-  List<Variable*, Allocator> locals(32);  // 32 is a wild guess
+  List<Variable*, Allocator> locals(32, allocator);  // 32 is a wild guess
   ASSERT(locals.is_empty());
   scope->CollectUsedVariables(&locals);
   locals.Sort(&CompareLocal);
 
-  List<Variable*, Allocator> heap_locals(locals.length());
+  List<Variable*, Allocator> heap_locals(locals.length(), allocator);
   for (int i = 0; i < locals.length(); i++) {
     Variable* var = locals[i];
     if (var->is_used()) {
       Slot* slot = var->AsSlot();
       if (slot != NULL) {
         switch (slot->type()) {
           case Slot::PARAMETER:
             // explicitly added to parameters_ above - ignore
             break;
 
@@ skipping 137 matching lines @@
     p = ReadSymbol(p, &s);
     p = ReadInt(p, &m);
     list->Add(s);
     modes->Add(static_cast<Variable::Mode>(m));
   }
   return p;
 }
 
 
 template<class Allocator>
-ScopeInfo<Allocator>::ScopeInfo(SerializedScopeInfo* data)
+ScopeInfo<Allocator>::ScopeInfo(SerializedScopeInfo* data,
+                                const Allocator& allocator)
   : function_name_(FACTORY->empty_symbol()),
-    parameters_(4),
-    stack_slots_(8),
-    context_slots_(8),
-    context_modes_(8) {
+    parameters_(4, allocator),
+    stack_slots_(8, allocator),
+    context_slots_(8, allocator),
+    context_modes_(8, allocator) {
   if (data->length() > 0) {
     Object** p0 = data->data_start();
     Object** p = p0;
     p = ReadSymbol(p, &function_name_);
     p = ReadBool(p, &calls_eval_);
     p = ReadBool(p, &is_strict_mode_);
     p = ReadList<Allocator>(p, &context_slots_, &context_modes_);
     p = ReadList<Allocator>(p, &parameters_);
     p = ReadList<Allocator>(p, &stack_slots_);
     ASSERT((p - p0) == FixedArray::cast(data)->length());
@@ skipping 90 matching lines @@
   int number_of_locals = number_of_stack_slots();
   if (number_of_context_slots() > 0) {
     ASSERT(number_of_context_slots() >= Context::MIN_CONTEXT_SLOTS);
     number_of_locals += number_of_context_slots() - Context::MIN_CONTEXT_SLOTS;
   }
   return number_of_locals;
 }
 
 
 Handle<SerializedScopeInfo> SerializedScopeInfo::Create(Scope* scope) {
-  ScopeInfo<ZoneListAllocationPolicy> sinfo(scope);
+  ScopeInfo<ZoneListAllocator> sinfo(scope, ZoneListAllocator(ZONE));
   return sinfo.Serialize();
 }
 
 
 SerializedScopeInfo* SerializedScopeInfo::Empty() {
   return reinterpret_cast<SerializedScopeInfo*>(HEAP->empty_fixed_array());
 }
 
 
 Object** SerializedScopeInfo::ContextEntriesAddr() {
@@ skipping 264 matching lines @@
   PrintList<Allocator>("stack slots", 0, stack_slots_);
   PrintList<Allocator>("context slots", Context::MIN_CONTEXT_SLOTS,
                        context_slots_);
 
   PrintF("}\n");
 }
 #endif  // DEBUG
 
 
 // Make sure the classes get instantiated by the template system.
-template class ScopeInfo<FreeStoreAllocationPolicy>;
-template class ScopeInfo<PreallocatedStorage>;
-template class ScopeInfo<ZoneListAllocationPolicy>;
+template class ScopeInfo<FreeStoreAllocator>;
+template class ScopeInfo<PreallocatedStorageAllocator>;
+template class ScopeInfo<ZoneListAllocator>;
 
 } }  // namespace v8::internal