Optimize the scope creation code by lazily allocating the hash maps...

src/scopes.cc

 // Copyright 2006-2008 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 94 matching lines @@
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 
 // Dummy constructor
 Scope::Scope()
   : inner_scopes_(0),
     locals_(false),
     temps_(0),
     params_(0),
-    dynamics_(false),
-    dynamics_local_(false),
-    dynamics_global_(false),
+    dynamics_(NULL),
     unresolved_(0),
     decls_(0) {
 }
 
 
 Scope::Scope(Scope* outer_scope, Type type)
   : outer_scope_(outer_scope),
     inner_scopes_(4),
     type_(type),
     scope_name_(Factory::empty_symbol()),
-    locals_(),
     temps_(4),
     params_(4),
+    dynamics_(NULL),
     unresolved_(16),
     decls_(4),
     receiver_(NULL),
     function_(NULL),
     arguments_(NULL),
     arguments_shadow_(NULL),
     illegal_redecl_(NULL),
     scope_inside_with_(false),
     scope_contains_with_(false),
     scope_calls_eval_(false),
@@ skipping 329 matching lines @@
 
   Indent(n1, "// temporary vars\n");
   for (int i = 0; i < temps_.length(); i++) {
     PrintVar(&printer, n1, temps_[i]);
   }
 
   Indent(n1, "// local vars\n");
   PrintMap(&printer, n1, &locals_);
 
   Indent(n1, "// dynamic vars\n");
-  PrintMap(&printer, n1, &dynamics_);
-  PrintMap(&printer, n1, &dynamics_local_);
-  PrintMap(&printer, n1, &dynamics_global_);
+  if (dynamics_ != NULL) {
+    PrintMap(&printer, n1, dynamics_->GetMap(Variable::DYNAMIC));
+    PrintMap(&printer, n1, dynamics_->GetMap(Variable::DYNAMIC_LOCAL));
+    PrintMap(&printer, n1, dynamics_->GetMap(Variable::DYNAMIC_GLOBAL));
+  }
 
   // Print inner scopes (disable by providing negative n).
   if (n >= 0) {
     for (int i = 0; i < inner_scopes_.length(); i++) {
       PrintF("\n");
       inner_scopes_[i]->Print(n1);
     }
   }
 
   Indent(n0, "}\n");
 }
 #endif  // DEBUG
 
 
 Variable* Scope::NonLocal(Handle<String> name, Variable::Mode mode) {
-  // Space optimization: reuse existing non-local with the same name
-  // and mode.
-  LocalsMap* map = NULL;
-  switch (mode) {
-    case Variable::DYNAMIC:
-      map = &dynamics_;
-      break;
-    case Variable::DYNAMIC_LOCAL:
-      map = &dynamics_local_;
-      break;
-    case Variable::DYNAMIC_GLOBAL:
-      map = &dynamics_global_;
-      break;
-    default:
-      UNREACHABLE();
-      break;
-  }
+  if (dynamics_ == NULL) dynamics_ = new DynamicScopePart();
+  LocalsMap* map = dynamics_->GetMap(mode);
   Variable* var = map->Lookup(name);
   if (var == NULL) {
     // Declare a new non-local.
     var = map->Declare(NULL, name, mode, true, false);
     // Allocate it by giving it a dynamic lookup.
     var->rewrite_ = new Slot(var, Slot::LOOKUP, -1);
   }
   return var;
 }
 
@@ skipping 419 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