[stubs] Use a single slot for context globals.

src/scopeinfo.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "src/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/scopeinfo.h"
@@ skipping 322 matching lines @@
     bool function_name_context_slot =
         FunctionVariableField::decode(Flags()) == CONTEXT;
     bool has_context = context_locals > 0 || context_globals > 0 ||
                        function_name_context_slot ||
                        scope_type() == WITH_SCOPE ||
                        (scope_type() == ARROW_SCOPE && CallsSloppyEval()) ||
                        (scope_type() == FUNCTION_SCOPE && CallsSloppyEval()) ||
                        scope_type() == MODULE_SCOPE;
 
     if (has_context) {
-      return Context::MIN_CONTEXT_SLOTS + context_locals + 2 * context_globals +
+      return Context::MIN_CONTEXT_SLOTS + context_locals + context_globals +
              (function_name_context_slot ? 1 : 0);
     }
   }
   return 0;
 }
 
 
 bool ScopeInfo::HasReceiver() {
   if (length() > 0) {
     return NONE != ReceiverVariableField::decode(Flags());
@@ skipping 192 matching lines @@
         *init_flag = scope_info->ContextLocalInitFlag(var);
         *maybe_assigned_flag = scope_info->ContextLocalMaybeAssignedFlag(var);
 
         if (var < scope_info->ContextLocalCount()) {
           *location = VariableLocation::CONTEXT;
           result = Context::MIN_CONTEXT_SLOTS + var;
         } else {
           var -= scope_info->ContextLocalCount();
           *location = VariableLocation::GLOBAL;
           result = Context::MIN_CONTEXT_SLOTS +
-                   scope_info->ContextLocalCount() + 2 * var;
+                   scope_info->ContextLocalCount() + var;
         }
 
         context_slot_cache->Update(scope_info, name, *mode, *location,
                                    *init_flag, *maybe_assigned_flag, result);
         DCHECK(result < scope_info->ContextLength());
         return result;
       }
     }
     // Cache as not found. Mode, location, init flag and maybe assigned flag
     // don't matter.
     context_slot_cache->Update(scope_info, name, TEMPORARY,
                                VariableLocation::CONTEXT, kNeedsInitialization,
                                kNotAssigned, -1);
   }
   return -1;
 }
 
 
 String* ScopeInfo::ContextSlotName(int slot_index) {
-  // TODO(bmeurer): Simplify this once we have only a single slot for both reads
-  // and writes to context globals;  currently we have 2 slots per context
-  // global, and these are located after the common context slots (of which we
-  // always have Context::MIN_CONTEXT_SLOTS) and the context locals.
-  int const var =
-      slot_index - (Context::MIN_CONTEXT_SLOTS + ContextLocalCount());
+  int const var = slot_index - Context::MIN_CONTEXT_SLOTS;
   DCHECK_LE(0, var);
-  DCHECK_LT(var, 2 * ContextGlobalCount());
-  return ContextLocalName(ContextLocalCount() + var / 2);
+  DCHECK_LT(var, ContextLocalCount() + ContextGlobalCount());
+  return ContextLocalName(var);
 }
 
 
 int ScopeInfo::ParameterIndex(String* name) {
   DCHECK(name->IsInternalizedString());
   if (length() > 0) {
     // We must read parameters from the end since for
     // multiply declared parameters the value of the
     // last declaration of that parameter is used
     // inside a function (and thus we need to look
@@ skipping 264 matching lines @@
     info->set_mode(i, var->mode());
     DCHECK(var->index() >= 0);
     info->set_index(i, var->index());
   }
   DCHECK(i == info->length());
   return info;
 }
 
 }  // namespace internal
 }  // namespace v8