Optimize loads from variables that might be shadowed by variables...

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 121 matching lines @@
     receiver_(NULL),
     function_(NULL),
     arguments_(NULL),
     arguments_shadow_(NULL),
     illegal_redecl_(NULL),
     scope_inside_with_(false),
     scope_contains_with_(false),
     scope_calls_eval_(false),
     outer_scope_calls_eval_(false),
     inner_scope_calls_eval_(false),
+    outer_scope_is_eval_scope_(false),
     force_eager_compilation_(false),
     num_stack_slots_(0),
     num_heap_slots_(0) {
   // 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());
 }
 
@@ skipping 153 matching lines @@
 
 void Scope::AllocateVariables() {
   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
   // the call chain stack, at compile time).
-  PropagateScopeInfo(is_eval_scope());
+  bool eval_scope = is_eval_scope();
+  PropagateScopeInfo(eval_scope, eval_scope);
 
   // 2) Resolve variables.
   Scope* global_scope = NULL;
   if (is_global_scope()) global_scope = this;
   ResolveVariablesRecursively(global_scope);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively();
 }
 
@@ skipping 109 matching lines @@
 
   // Scope info.
   if (HasTrivialOuterContext()) {
     Indent(n1, "// scope has trivial outer context\n");
   }
   if (scope_inside_with_) Indent(n1, "// scope inside 'with'\n");
   if (scope_contains_with_) Indent(n1, "// scope contains 'with'\n");
   if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
   if (outer_scope_calls_eval_) Indent(n1, "// outer scope calls 'eval'\n");
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
+  if (outer_scope_is_eval_scope_) Indent(n1, "// outer scope is 'eval' scope\n");
   if (num_stack_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d stack slots\n", num_stack_slots_); }
   if (num_heap_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d heap slots\n", num_heap_slots_); }
 
   // Print locals.
   PrettyPrinter printer;
   Indent(n1, "// function var\n");
   if (function_ != NULL) {
     PrintVar(&printer, n1, function_);
@@ skipping 20 matching lines @@
       PrintF("\n");
       inner_scopes_[i]->Print(n1);
     }
   }
 
   Indent(n0, "}\n");
 }
 #endif  // DEBUG
 
 
-Variable* Scope::NonLocal(Handle<String> name) {
-  // Space optimization: reuse existing non-local with the same name.
+Variable* Scope::NonLocal(Handle<String> name, Variable::Mode mode) {
+  // Space optimization: reuse existing non-local with the same name
+  // and mode.
   for (int i = 0; i < nonlocals_.length(); i++) {
     Variable* var = nonlocals_[i];
-    if (var->name().is_identical_to(name)) {
-      ASSERT(var->mode() == Variable::DYNAMIC);
+    if (var->name().is_identical_to(name) && var->mode() == mode) {
       return var;
     }
   }
 
-  // Otherwise create a new new-local and add it to the list.
-  Variable* var = new Variable(
-    NULL /* we don't know the scope */,
-    name, Variable::DYNAMIC, true, false);
+  // Otherwise create a new non-local and add it to the list.
+  Variable* var = new Variable(NULL, name, mode, true, false);
   nonlocals_.Add(var);
 
   // Allocate it by giving it a dynamic lookup.
   var->rewrite_ = new Slot(var, Slot::LOOKUP, -1);
 
   return var;
 }
 
 
 // Lookup a variable starting with this scope. The result is either
 // the statically resolved (local!) variable belonging to an outer scope,
 // or NULL. It may be NULL because a) we couldn't find a variable, or b)
 // because the variable is just a guess (and may be shadowed by another
 // variable that is introduced dynamically via an 'eval' call or a 'with'
 // statement).
-Variable* Scope::LookupRecursive(Handle<String> name, bool inner_lookup) {
+Variable* Scope::LookupRecursive(Handle<String> name,
+                                 bool inner_lookup,
+                                 Variable** invalidated_local) {
   // If we find a variable, but the current scope calls 'eval', the found
   // variable may not be the correct one (the 'eval' may introduce a
   // property with the same name). In that case, remember that the variable
   // found is just a guess.
   bool guess = scope_calls_eval_;
 
   // Try to find the variable in this scope.
   Variable* var = LookupLocal(name);
 
   if (var != NULL) {
@@ skipping 10 matching lines @@
     // only present - if at all - for function scopes.
     //
     // This lookup corresponds to a lookup in the "intermediate" scope sitting
     // between this scope and the outer scope. (ECMA-262, 3rd., requires that
     // the name of named function literal is kept in an intermediate scope
     // in between this scope and the next outer scope.)
     if (function_ != NULL && function_->name().is_identical_to(name)) {
       var = function_;
 
     } else if (outer_scope_ != NULL) {
-      var = outer_scope_->LookupRecursive(name, true /* inner lookup */);
+      var = outer_scope_->LookupRecursive(name, true, invalidated_local);
       // We may have found a variable in an outer scope. However, if
       // the current scope is inside a 'with', the actual variable may
       // be a property introduced via the 'with' statement. Then, the
       // variable we may have found is just a guess.
       if (scope_inside_with_)
         guess = true;
     }
 
     // If we did not find a variable, we are done.
     if (var == NULL)
       return NULL;
   }
 
   ASSERT(var != NULL);
 
   // If this is a lookup from an inner scope, mark the variable.
   if (inner_lookup)
     var->is_accessed_from_inner_scope_ = true;
 
   // If the variable we have found is just a guess, invalidate the result.
-  if (guess)
+  if (guess) {
+    *invalidated_local = var;
     var = NULL;
+  }
 
   return var;
 }
 
 
 void Scope::ResolveVariable(Scope* global_scope, VariableProxy* proxy) {
   ASSERT(global_scope == NULL || global_scope->is_global_scope());
 
   // If the proxy is already resolved there's nothing to do
   // (functions and consts may be resolved by the parser).
   if (proxy->var() != NULL) return;
 
   // Otherwise, try to resolve the variable.
-  Variable* var = LookupRecursive(proxy->name(), false);
+  Variable* invalidated_local = NULL;
+  Variable* var = LookupRecursive(proxy->name(), false, &invalidated_local);
 
   if (proxy->inside_with()) {
     // If we are inside a local 'with' statement, all bets are off
     // and we cannot resolve the proxy to a local variable even if
     // we found an outer matching variable.
     // Note that we must do a lookup anyway, because if we find one,
     // we must mark that variable as potentially accessed from this
     // inner scope (the property may not be in the 'with' object).
-    var = NonLocal(proxy->name());
+    var = NonLocal(proxy->name(), Variable::DYNAMIC);
 
   } else {
     // We are not inside a local 'with' statement.
 
     if (var == NULL) {
       // We did not find the variable. We have a global variable
       // if we are in the global scope (we know already that we
       // are outside a 'with' statement) or if there is no way
       // that the variable might be introduced dynamically (through
       // a local or outer eval() call, or an outer 'with' statement),
       // or we don't know about the outer scope (because we are
       // in an eval scope).
       if (!is_global_scope() &&
-          (is_eval_scope() || outer_scope_calls_eval_ ||
-           scope_calls_eval_ || scope_inside_with_)) {
-        // We must look up the variable at runtime, and we don't
-        // know anything else.
-        var = NonLocal(proxy->name());
+          (scope_inside_with_ || outer_scope_is_eval_scope_)) {
+        // If we are inside a with statement or the code is executed
+        // using eval, we give up and look up the variable at runtime.
+        var = NonLocal(proxy->name(), Variable::DYNAMIC);
+
+      } else if (!is_global_scope() &&
+                 (scope_calls_eval_ || outer_scope_calls_eval_)) {
+        // If the code is not executed using eval and there are no
+        // with scopes, either we have a local or a global variable
+        // that might be shadowed by an eval-introduced variable.
+        if (invalidated_local != NULL) {
+          var = NonLocal(proxy->name(), Variable::DYNAMIC_LOCAL);
+          var->set_local_if_not_shadowed(invalidated_local);
+        } else {
+          var = NonLocal(proxy->name(), Variable::DYNAMIC_GLOBAL);
+        }
 
       } else {
         // We must have a global variable.
         ASSERT(global_scope != NULL);
         var = new Variable(global_scope, proxy->name(),
                            Variable::DYNAMIC, true, false);
         // Ideally we simply rewrite these variables into property
         // accesses. Unfortunately, we cannot do this here at the
         // moment because then we can't differentiate between
         // global variable ('x') and global property ('this.x') access.
@@ skipping 17 matching lines @@
     ResolveVariable(global_scope, unresolved_[i]);
   }
 
   // Resolve unresolved variables for inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     inner_scopes_[i]->ResolveVariablesRecursively(global_scope);
   }
 }
 
 
-bool Scope::PropagateScopeInfo(bool outer_scope_calls_eval) {
+bool Scope::PropagateScopeInfo(bool outer_scope_calls_eval,
+                               bool outer_scope_is_eval_scope) {
   if (outer_scope_calls_eval) {
     outer_scope_calls_eval_ = true;
   }
 
-  bool b = scope_calls_eval_ || outer_scope_calls_eval_;
+  if (outer_scope_is_eval_scope) {
+    outer_scope_is_eval_scope_ = true;
+  }
+
+  bool calls_eval = scope_calls_eval_ || outer_scope_calls_eval_;
+  bool is_eval = is_eval_scope() || outer_scope_is_eval_scope_;
   for (int i = 0; i < inner_scopes_.length(); i++) {
     Scope* inner_scope = inner_scopes_[i];
-    if (inner_scope->PropagateScopeInfo(b)) {
+    if (inner_scope->PropagateScopeInfo(calls_eval, is_eval)) {
       inner_scope_calls_eval_ = true;
     }
     if (inner_scope->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
   }
 
   return scope_calls_eval_ || inner_scope_calls_eval_;
 }
 
@@ skipping 227 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