Initialize num_heap_slots_ to MIN_CONTEXT_SLOTS in SetDefaults, make already_resolved_ debug-only

src/ast/scopes.cc

 // Copyright 2012 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 "src/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 62 matching lines @@
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)
     : zone_(zone),
       outer_scope_(outer_scope),
       variables_(zone),
       decls_(4, zone),
-      scope_type_(scope_type),
-      already_resolved_(false) {
+      scope_type_(scope_type) {
   SetDefaults();
   if (outer_scope == nullptr) {
     // If the outer scope is null, this cannot be a with scope. The outermost
     // scope must be a script scope.
     DCHECK_EQ(SCRIPT_SCOPE, scope_type);
   } else {
     asm_function_ = outer_scope_->asm_module_;
     // Inherit the language mode from the parent scope unless we're a module
     // scope.
     if (!is_module_scope()) language_mode_ = outer_scope->language_mode_;
@@ skipping 25 matching lines @@
   }
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       decls_(0, zone),
       scope_info_(scope_info),
-      scope_type_(scope_type),
-      already_resolved_(true) {
+      scope_type_(scope_type) {
   SetDefaults();
+#ifdef DEBUG
+  already_resolved_ = true;
+#endif
   if (scope_type == WITH_SCOPE) {
     DCHECK(scope_info.is_null());
-    // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
-    num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   } else {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     num_heap_slots_ = scope_info->ContextLength();
-    DCHECK_LE(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
   }
+  DCHECK_LE(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   if (inner_scope != nullptr) AddInnerScope(inner_scope);
 }
 
 DeclarationScope::DeclarationScope(Zone* zone, Scope* inner_scope,
                                    ScopeType scope_type,
                                    Handle<ScopeInfo> scope_info)
     : Scope(zone, inner_scope, scope_type, scope_info),
       function_kind_(scope_info->function_kind()),
       temps_(0, zone),
       params_(0, zone),
       sloppy_block_function_map_(zone) {
   SetDefaults();
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
              const AstRawString* catch_variable_name)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       decls_(0, zone),
-      scope_type_(CATCH_SCOPE),
-      already_resolved_(true) {
+      scope_type_(CATCH_SCOPE) {
   SetDefaults();
+#ifdef DEBUG
+  already_resolved_ = true;
+#endif
   if (inner_scope != nullptr) AddInnerScope(inner_scope);
-  num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable =
       variables_.Declare(zone, this, catch_variable_name, VAR, Variable::NORMAL,
                          kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 void DeclarationScope::SetDefaults() {
   is_declaration_scope_ = true;
   has_simple_parameters_ = true;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
   arity_ = 0;
   rest_parameter_ = nullptr;
   rest_index_ = -1;
   module_descriptor_ = nullptr;
 }
 
 void Scope::SetDefaults() {
 #ifdef DEBUG
   scope_name_ = nullptr;
+  already_resolved_ = false;
 #endif
   inner_scope_ = nullptr;
   sibling_ = nullptr;
   unresolved_ = nullptr;
   dynamics_ = nullptr;
 
   start_position_ = kNoSourcePosition;
   end_position_ = kNoSourcePosition;
 
   num_stack_slots_ = 0;
-  num_heap_slots_ = 0;
+  num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   num_global_slots_ = 0;
 
   language_mode_ = SLOPPY;
 
   scope_inside_with_ = false;
   scope_calls_eval_ = false;
   scope_uses_super_property_ = false;
   has_arguments_parameter_ = false;
   asm_module_ = false;
   asm_function_ = false;
@@ skipping 161 matching lines @@
 void Scope::Analyze(ParseInfo* info) {
   DCHECK(info->literal() != NULL);
   DeclarationScope* scope = info->literal()->scope();
 
   // We are compiling one of three cases:
   // 1) top-level code,
   // 2) a function/eval/module on the top-level
   // 3) a function/eval in a scope that was already resolved.
   DCHECK(scope->scope_type() == SCRIPT_SCOPE ||
          scope->outer_scope()->scope_type() == SCRIPT_SCOPE ||
-         scope->outer_scope()->already_resolved());
+         scope->outer_scope()->already_resolved_);
 
   // Allocate the variables.
   {
     AstNodeFactory ast_node_factory(info->ast_value_factory());
     scope->AllocateVariables(info, &ast_node_factory);
   }
 
 #ifdef DEBUG
   if (info->script_is_native() ? FLAG_print_builtin_scopes
                                : FLAG_print_scopes) {
     scope->Print();
   }
   scope->CheckScopePositions();
   scope->CheckZones();
 #endif
 }
 
 void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {
-  DCHECK(!already_resolved());
+  DCHECK(!already_resolved_);
   DCHECK(is_declaration_scope());
   DCHECK(has_this_declaration());
 
   bool subclass_constructor = IsSubclassConstructor(function_kind_);
   Variable* var = variables_.Declare(
       zone(), this, ast_value_factory->this_string(),
       subclass_constructor ? CONST : VAR, Variable::THIS,
       subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
   receiver_ = var;
 }
@@ skipping 61 matching lines @@
       while (unresolved->next_unresolved() != nullptr) {
         unresolved = unresolved->next_unresolved();
       }
       unresolved->set_next_unresolved(outer_scope()->unresolved_);
     }
     outer_scope()->unresolved_ = unresolved_;
     unresolved_ = nullptr;
   }
 
   PropagateUsageFlagsToScope(outer_scope_);
-
+  // This block does not need a context.
+  num_heap_slots_ = 0;
   return NULL;
 }
 
 void Scope::Snapshot::Reparent(DeclarationScope* new_parent) const {
   DCHECK_EQ(new_parent, outer_scope_->inner_scope_);
   DCHECK_EQ(new_parent->outer_scope_, outer_scope_);
   DCHECK_EQ(new_parent, new_parent->GetClosureScope());
   DCHECK_NULL(new_parent->inner_scope_);
   DCHECK_NULL(new_parent->unresolved_);
   DCHECK_EQ(0, new_parent->temps()->length());
@@ skipping 32 matching lines @@
       temp->set_scope(new_parent);
       new_parent->AddTemporary(temp);
     }
     temps->Rewind(top_temp_);
   }
 }
 
 void Scope::ReplaceOuterScope(Scope* outer) {
   DCHECK_NOT_NULL(outer);
   DCHECK_NOT_NULL(outer_scope_);
-  DCHECK(!already_resolved());
-  DCHECK(!outer->already_resolved());
-  DCHECK(!outer_scope_->already_resolved());
+  DCHECK(!already_resolved_);

[ortuno, 2016/08/19 02:20:54]

This line is causing a crash in Debug builds. Is it a known issue?

+  DCHECK(!outer->already_resolved_);
+  DCHECK(!outer_scope_->already_resolved_);
   outer_scope_->RemoveInnerScope(this);
   outer->AddInnerScope(this);
   outer_scope_ = outer;
 }
 
 
 void Scope::PropagateUsageFlagsToScope(Scope* other) {
   DCHECK_NOT_NULL(other);
-  DCHECK(!already_resolved());
-  DCHECK(!other->already_resolved());
+  DCHECK(!already_resolved_);
+  DCHECK(!other->already_resolved_);
   if (uses_super_property()) other->RecordSuperPropertyUsage();
   if (calls_eval()) other->RecordEvalCall();
 }
 
 
 Variable* Scope::LookupLocal(const AstRawString* name) {
   Variable* result = variables_.Lookup(name);
   if (result != NULL || scope_info_.is_null()) {
     return result;
   }
@@ skipping 73 matching lines @@
        scope = scope->outer_scope()) {
     Variable* var = scope->LookupLocal(name);
     if (var != NULL) return var;
   }
   return NULL;
 }
 
 Variable* DeclarationScope::DeclareParameter(
     const AstRawString* name, VariableMode mode, bool is_optional, bool is_rest,
     bool* is_duplicate, AstValueFactory* ast_value_factory) {
-  DCHECK(!already_resolved());
+  DCHECK(!already_resolved_);
   DCHECK(is_function_scope());
   DCHECK(!is_optional || !is_rest);
   Variable* var;
   if (mode == TEMPORARY) {
     var = NewTemporary(name);
   } else {
     var = variables_.Declare(zone(), this, name, mode, Variable::NORMAL,
                              kCreatedInitialized);
     // TODO(wingo): Avoid O(n^2) check.
     *is_duplicate = IsDeclaredParameter(name);
   }
   if (!is_optional && !is_rest && arity_ == params_.length()) {
     ++arity_;
   }
   if (is_rest) {
     DCHECK_NULL(rest_parameter_);
     rest_parameter_ = var;
     rest_index_ = num_parameters();
   }
   params_.Add(var, zone());
   if (name == ast_value_factory->arguments_string()) {
     has_arguments_parameter_ = true;
   }
   return var;
 }
 
 Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
                               InitializationFlag init_flag, Variable::Kind kind,
                               MaybeAssignedFlag maybe_assigned_flag) {
-  DCHECK(!already_resolved());
+  DCHECK(!already_resolved_);
   // This function handles VAR, LET, and CONST modes.  DYNAMIC variables are
   // introduced during variable allocation, and TEMPORARY variables are
   // allocated via NewTemporary().
   DCHECK(IsDeclaredVariableMode(mode));
   return variables_.Declare(zone(), this, name, mode, kind, init_flag,
                             maybe_assigned_flag);
 }
 
 Variable* DeclarationScope::DeclareDynamicGlobal(const AstRawString* name,
                                                  Variable::Kind kind) {
@@ skipping 28 matching lines @@
   Variable* var = new(zone()) Variable(scope,
                                        name,
                                        TEMPORARY,
                                        Variable::NORMAL,
                                        kCreatedInitialized);
   scope->AddTemporary(var);
   return var;
 }
 
 void Scope::AddDeclaration(Declaration* declaration) {
-  DCHECK(!already_resolved());
+  DCHECK(!already_resolved_);
   decls_.Add(declaration, zone());
 }
 
 
 Declaration* Scope::CheckConflictingVarDeclarations() {
   int length = decls_.length();
   for (int i = 0; i < length; i++) {
     Declaration* decl = decls_[i];
     VariableMode mode = decl->proxy()->var()->mode();
     if (IsLexicalVariableMode(mode) && !is_block_scope()) continue;
@@ skipping 560 matching lines @@
     // TODO(wingo): There are other variables in this category; add them.
     if (var != nullptr && var->is_this()) return var;
 
     if (is_with_scope()) {
       // The current scope is a with scope, so the variable binding can not be
       // statically resolved. However, note that it was necessary to do a lookup
       // in the outer scope anyway, because if a binding exists in an outer
       // scope, the associated variable has to be marked as potentially being
       // accessed from inside of an inner with scope (the property may not be in
       // the 'with' object).
-      if (var != nullptr && !already_resolved()) {
+      if (var != nullptr && var->IsUnallocated()) {
+        DCHECK(!already_resolved_);
         var->set_is_used();
         var->ForceContextAllocation();
         if (proxy->is_assigned()) var->set_maybe_assigned();
       }
       *binding_kind = DYNAMIC_LOOKUP;
       return nullptr;
     }
   } else {
     DCHECK(!is_with_scope());
     DCHECK(is_function_scope() || is_script_scope() || is_eval_scope());
@@ skipping 383 matching lines @@
   }
 
   for (auto entry : module()->exports()) {
     if (entry->local_name == nullptr) continue;
     Variable* var = LookupLocal(entry->local_name);
     var->AllocateTo(VariableLocation::MODULE, 42);
   }
 }
 
 void Scope::AllocateVariablesRecursively() {
-  if (!already_resolved()) {
-    num_stack_slots_ = 0;
-  }
+  DCHECK(!already_resolved_);
+  DCHECK_EQ(0, num_stack_slots_);
+
   // Allocate variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     scope->AllocateVariablesRecursively();
   }
 
-  // If scope is already resolved, we still need to allocate
-  // variables in inner scopes which might not have been resolved yet.
-  if (already_resolved()) return;
-  // The number of slots required for variables.
-  num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
+  DCHECK(!already_resolved_);
+  DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
   if (is_declaration_scope()) {
     if (is_module_scope()) {
       AsDeclarationScope()->AllocateModuleVariables();
     } else if (is_function_scope()) {
       AsDeclarationScope()->AllocateParameterLocals();
     }
     AsDeclarationScope()->AllocateReceiver();
@@ skipping 36 matching lines @@
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8