Roll V8 back to 3.6
Roll back to V8 3.6 to fix x86 build, we don't have ucontext.h.
This reverts commits:
5d4cdbf7a67d3662fa0bee4efdb7edd8daec9b0b
c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9
592a9fc1d8ea420377a2e7efd0600e20b058be2b
Bug: 5688872
Change-Id: Ic961bb5e65b778e98bbfb71cce71d99fa949e995
diff --git a/src/scopes.h b/src/scopes.h
index d315b7e..2917a63 100644
--- a/src/scopes.h
+++ b/src/scopes.h
@@ -1,4 +1,4 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
+// 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:
@@ -29,7 +29,7 @@
#define V8_SCOPES_H_
#include "ast.h"
-#include "zone.h"
+#include "hashmap.h"
namespace v8 {
namespace internal {
@@ -38,19 +38,21 @@
// A hash map to support fast variable declaration and lookup.
-class VariableMap: public ZoneHashMap {
+class VariableMap: public HashMap {
public:
VariableMap();
+ // Dummy constructor. This constructor doesn't set up the map
+ // properly so don't use it unless you have a good reason.
+ explicit VariableMap(bool gotta_love_static_overloading);
+
virtual ~VariableMap();
Variable* Declare(Scope* scope,
Handle<String> name,
- VariableMode mode,
+ Variable::Mode mode,
bool is_valid_lhs,
- Variable::Kind kind,
- InitializationFlag initialization_flag,
- Interface* interface = Interface::NewValue());
+ Variable::Kind kind);
Variable* Lookup(Handle<String> name);
};
@@ -62,8 +64,8 @@
// and setup time for scopes that don't need them.
class DynamicScopePart : public ZoneObject {
public:
- VariableMap* GetMap(VariableMode mode) {
- int index = mode - DYNAMIC;
+ VariableMap* GetMap(Variable::Mode mode) {
+ int index = mode - Variable::DYNAMIC;
ASSERT(index >= 0 && index < 3);
return &maps_[index];
}
@@ -87,19 +89,28 @@
// ---------------------------------------------------------------------------
// Construction
- Scope(Scope* outer_scope, ScopeType type);
+ enum Type {
+ EVAL_SCOPE, // The top-level scope for an eval source.
+ FUNCTION_SCOPE, // The top-level scope for a function.
+ GLOBAL_SCOPE, // The top-level scope for a program or a top-level eval.
+ CATCH_SCOPE, // The scope introduced by catch.
+ BLOCK_SCOPE // The scope introduced by a new block.
+ };
+
+ Scope(Scope* outer_scope, Type type);
// Compute top scope and allocate variables. For lazy compilation the top
// scope only contains the single lazily compiled function, so this
// doesn't re-allocate variables repeatedly.
static bool Analyze(CompilationInfo* info);
- static Scope* DeserializeScopeChain(Context* context, Scope* global_scope);
+ static Scope* DeserializeScopeChain(CompilationInfo* info,
+ Scope* innermost_scope);
// The scope name is only used for printing/debugging.
void SetScopeName(Handle<String> scope_name) { scope_name_ = scope_name; }
- void Initialize();
+ void Initialize(bool inside_with);
// Checks if the block scope is redundant, i.e. it does not contain any
// block scoped declarations. In that case it is removed from the scope
@@ -112,13 +123,6 @@
// Lookup a variable in this scope. Returns the variable or NULL if not found.
Variable* LocalLookup(Handle<String> name);
- // 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.)
- Variable* LookupFunctionVar(Handle<String> name,
- AstNodeFactory<AstNullVisitor>* factory);
-
// Lookup a variable in this scope or outer scopes.
// Returns the variable or NULL if not found.
Variable* Lookup(Handle<String> name);
@@ -126,28 +130,16 @@
// Declare the function variable for a function literal. This variable
// is in an intermediate scope between this function scope and the the
// outer scope. Only possible for function scopes; at most one variable.
- template<class Visitor>
- Variable* DeclareFunctionVar(Handle<String> name,
- VariableMode mode,
- AstNodeFactory<Visitor>* factory) {
- ASSERT(is_function_scope() && function_ == NULL);
- Variable* function_var = new Variable(
- this, name, mode, true, Variable::NORMAL, kCreatedInitialized);
- function_ = factory->NewVariableProxy(function_var);
- return function_var;
- }
+ Variable* DeclareFunctionVar(Handle<String> name);
// Declare a parameter in this scope. When there are duplicated
// parameters the rightmost one 'wins'. However, the implementation
// expects all parameters to be declared and from left to right.
- void DeclareParameter(Handle<String> name, VariableMode mode);
+ void DeclareParameter(Handle<String> name, Variable::Mode mode);
// Declare a local variable in this scope. If the variable has been
// declared before, the previously declared variable is returned.
- Variable* DeclareLocal(Handle<String> name,
- VariableMode mode,
- InitializationFlag init_flag,
- Interface* interface = Interface::NewValue());
+ Variable* DeclareLocal(Handle<String> name, Variable::Mode mode);
// Declare an implicit global variable in this scope which must be a
// global scope. The variable was introduced (possibly from an inner
@@ -156,20 +148,9 @@
Variable* DeclareGlobal(Handle<String> name);
// Create a new unresolved variable.
- template<class Visitor>
- VariableProxy* NewUnresolved(AstNodeFactory<Visitor>* factory,
- Handle<String> name,
- int position = RelocInfo::kNoPosition,
- Interface* interface = Interface::NewValue()) {
- // Note that we must not share the unresolved variables with
- // the same name because they may be removed selectively via
- // RemoveUnresolved().
- ASSERT(!already_resolved());
- VariableProxy* proxy =
- factory->NewVariableProxy(name, false, position, interface);
- unresolved_.Add(proxy);
- return proxy;
- }
+ VariableProxy* NewUnresolved(Handle<String> name,
+ bool inside_with,
+ int position = RelocInfo::kNoPosition);
// Remove a unresolved variable. During parsing, an unresolved variable
// may have been added optimistically, but then only the variable name
@@ -211,11 +192,6 @@
// scope over a let binding of the same name.
Declaration* CheckConflictingVarDeclarations();
- // For harmony block scoping mode: Check if the scope has variable proxies
- // that are used as lvalues and point to const variables. Assumes that scopes
- // have been analyzed and variables been resolved.
- VariableProxy* CheckAssignmentToConst();
-
// ---------------------------------------------------------------------------
// Scope-specific info.
@@ -223,42 +199,11 @@
void RecordWithStatement() { scope_contains_with_ = true; }
// Inform the scope that the corresponding code contains an eval call.
- void RecordEvalCall() { if (!is_global_scope()) scope_calls_eval_ = true; }
+ void RecordEvalCall() { scope_calls_eval_ = true; }
- // Set the strict mode flag (unless disabled by a global flag).
- void SetLanguageMode(LanguageMode language_mode) {
- language_mode_ = language_mode;
- }
-
- // Position in the source where this scope begins and ends.
- //
- // * For the scope of a with statement
- // with (obj) stmt
- // start position: start position of first token of 'stmt'
- // end position: end position of last token of 'stmt'
- // * For the scope of a block
- // { stmts }
- // start position: start position of '{'
- // end position: end position of '}'
- // * For the scope of a function literal or decalaration
- // function fun(a,b) { stmts }
- // start position: start position of '('
- // end position: end position of '}'
- // * For the scope of a catch block
- // try { stms } catch(e) { stmts }
- // start position: start position of '('
- // end position: end position of ')'
- // * For the scope of a for-statement
- // for (let x ...) stmt
- // start position: start position of '('
- // end position: end position of last token of 'stmt'
- int start_position() const { return start_position_; }
- void set_start_position(int statement_pos) {
- start_position_ = statement_pos;
- }
- int end_position() const { return end_position_; }
- void set_end_position(int statement_pos) {
- end_position_ = statement_pos;
+ // Enable strict mode for the scope (unless disabled by a global flag).
+ void EnableStrictMode() {
+ strict_mode_ = FLAG_strict_mode;
}
// ---------------------------------------------------------------------------
@@ -267,29 +212,17 @@
// Specific scope types.
bool is_eval_scope() const { return type_ == EVAL_SCOPE; }
bool is_function_scope() const { return type_ == FUNCTION_SCOPE; }
- bool is_module_scope() const { return type_ == MODULE_SCOPE; }
bool is_global_scope() const { return type_ == GLOBAL_SCOPE; }
bool is_catch_scope() const { return type_ == CATCH_SCOPE; }
bool is_block_scope() const { return type_ == BLOCK_SCOPE; }
- bool is_with_scope() const { return type_ == WITH_SCOPE; }
- bool is_declaration_scope() const {
- return is_eval_scope() || is_function_scope() || is_global_scope();
- }
- bool is_classic_mode() const {
- return language_mode() == CLASSIC_MODE;
- }
- bool is_extended_mode() const {
- return language_mode() == EXTENDED_MODE;
- }
- bool is_strict_or_extended_eval_scope() const {
- return is_eval_scope() && !is_classic_mode();
+ bool is_strict_mode() const { return strict_mode_; }
+ bool is_strict_mode_eval_scope() const {
+ return is_eval_scope() && is_strict_mode();
}
// Information about which scopes calls eval.
bool calls_eval() const { return scope_calls_eval_; }
- bool calls_non_strict_eval() {
- return scope_calls_eval_ && is_classic_mode();
- }
+ bool outer_scope_calls_eval() const { return outer_scope_calls_eval_; }
bool outer_scope_calls_non_strict_eval() const {
return outer_scope_calls_non_strict_eval_;
}
@@ -299,15 +232,12 @@
// Does this scope contain a with statement.
bool contains_with() const { return scope_contains_with_; }
+ // The scope immediately surrounding this scope, or NULL.
+ Scope* outer_scope() const { return outer_scope_; }
+
// ---------------------------------------------------------------------------
// Accessors.
- // The type of this scope.
- ScopeType type() const { return type_; }
-
- // The language mode of this scope.
- LanguageMode language_mode() const { return language_mode_; }
-
// The variable corresponding the 'this' value.
Variable* receiver() { return receiver_; }
@@ -334,23 +264,23 @@
// Declarations list.
ZoneList<Declaration*>* declarations() { return &decls_; }
- // Inner scope list.
- ZoneList<Scope*>* inner_scopes() { return &inner_scopes_; }
-
- // The scope immediately surrounding this scope, or NULL.
- Scope* outer_scope() const { return outer_scope_; }
-
- // The interface as inferred so far; only for module scopes.
- Interface* interface() const { return interface_; }
// ---------------------------------------------------------------------------
// Variable allocation.
- // Collect stack and context allocated local variables in this scope. Note
- // that the function variable - if present - is not collected and should be
- // handled separately.
- void CollectStackAndContextLocals(ZoneList<Variable*>* stack_locals,
- ZoneList<Variable*>* context_locals);
+ // Collect all used locals in this scope.
+ template<class Allocator>
+ void CollectUsedVariables(List<Variable*, Allocator>* locals);
+
+ // Resolve and fill in the allocation information for all variables
+ // in this scopes. Must be called *after* all scopes have been
+ // processed (parsed) to ensure that unresolved variables can be
+ // resolved properly.
+ //
+ // In the case of code compiled and run using 'eval', the context
+ // parameter is the context in which eval was called. In all other
+ // cases the context parameter is an empty handle.
+ void AllocateVariables(Handle<Context> context);
// Current number of var or const locals.
int num_var_or_const() { return num_var_or_const_; }
@@ -359,20 +289,12 @@
int num_stack_slots() const { return num_stack_slots_; }
int num_heap_slots() const { return num_heap_slots_; }
- int StackLocalCount() const;
- int ContextLocalCount() const;
-
// Make sure this scope and all outer scopes are eagerly compiled.
void ForceEagerCompilation() { force_eager_compilation_ = true; }
// Determine if we can use lazy compilation for this scope.
bool AllowsLazyCompilation() const;
- // True if we can lazily recompile functions with this scope.
- bool allows_lazy_recompilation() const {
- return !force_eager_compilation_;
- }
-
// True if the outer context of this scope is always the global context.
bool HasTrivialOuterContext() const;
@@ -383,14 +305,7 @@
// where var declarations will be hoisted to in the implementation.
Scope* DeclarationScope();
- Handle<ScopeInfo> GetScopeInfo();
-
- // Get the chain of nested scopes within this scope for the source statement
- // position. The scopes will be added to the list from the outermost scope to
- // the innermost scope. Only nested block, catch or with scopes are tracked
- // and will be returned, but no inner function scopes.
- void GetNestedScopeChain(List<Handle<ScopeInfo> >* chain,
- int statement_position);
+ Handle<SerializedScopeInfo> GetSerializedScopeInfo();
// ---------------------------------------------------------------------------
// Strict mode support.
@@ -415,6 +330,8 @@
protected:
friend class ParserFactory;
+ explicit Scope(Type type);
+
Isolate* const isolate_;
// Scope tree.
@@ -422,7 +339,7 @@
ZoneList<Scope*> inner_scopes_; // the immediately enclosed inner scopes
// The scope type.
- ScopeType type_;
+ Type type_;
// Debugging support.
Handle<String> scope_name_;
@@ -449,8 +366,6 @@
VariableProxy* function_;
// Convenience variable; function scopes only.
Variable* arguments_;
- // Interface; module scopes only.
- Interface* interface_;
// Illegal redeclaration.
Expression* illegal_redecl_;
@@ -464,15 +379,14 @@
// This scope or a nested catch scope or with scope contain an 'eval' call. At
// the 'eval' call site this scope is the declaration scope.
bool scope_calls_eval_;
- // The language mode of this scope.
- LanguageMode language_mode_;
- // Source positions.
- int start_position_;
- int end_position_;
+ // This scope is a strict mode scope.
+ bool strict_mode_;
// Computed via PropagateScopeInfo.
+ bool outer_scope_calls_eval_;
bool outer_scope_calls_non_strict_eval_;
bool inner_scope_calls_eval_;
+ bool outer_scope_is_eval_scope_;
bool force_eager_compilation_;
// True if it doesn't need scope resolution (e.g., if the scope was
@@ -482,80 +396,32 @@
// Computed as variables are declared.
int num_var_or_const_;
- // Computed via AllocateVariables; function, block and catch scopes only.
+ // Computed via AllocateVariables; function scopes only.
int num_stack_slots_;
int num_heap_slots_;
- // Serialized scope info support.
- Handle<ScopeInfo> scope_info_;
+ // Serialized scopes support.
+ Handle<SerializedScopeInfo> scope_info_;
bool already_resolved() { return already_resolved_; }
// Create a non-local variable with a given name.
// These variables are looked up dynamically at runtime.
- Variable* NonLocal(Handle<String> name, VariableMode mode);
+ Variable* NonLocal(Handle<String> name, Variable::Mode mode);
// Variable resolution.
- // Possible results of a recursive variable lookup telling if and how a
- // variable is bound. These are returned in the output parameter *binding_kind
- // of the LookupRecursive function.
- enum BindingKind {
- // The variable reference could be statically resolved to a variable binding
- // which is returned. There is no 'with' statement between the reference and
- // the binding and no scope between the reference scope (inclusive) and
- // binding scope (exclusive) makes a non-strict 'eval' call.
- BOUND,
-
- // The variable reference could be statically resolved to a variable binding
- // which is returned. There is no 'with' statement between the reference and
- // the binding, but some scope between the reference scope (inclusive) and
- // binding scope (exclusive) makes a non-strict 'eval' call, that might
- // possibly introduce variable bindings shadowing the found one. Thus the
- // found variable binding is just a guess.
- BOUND_EVAL_SHADOWED,
-
- // The variable reference could not be statically resolved to any binding
- // and thus should be considered referencing a global variable. NULL is
- // returned. The variable reference is not inside any 'with' statement and
- // no scope between the reference scope (inclusive) and global scope
- // (exclusive) makes a non-strict 'eval' call.
- UNBOUND,
-
- // The variable reference could not be statically resolved to any binding
- // NULL is returned. The variable reference is not inside any 'with'
- // statement, but some scope between the reference scope (inclusive) and
- // global scope (exclusive) makes a non-strict 'eval' call, that might
- // possibly introduce a variable binding. Thus the reference should be
- // considered referencing a global variable unless it is shadowed by an
- // 'eval' introduced binding.
- UNBOUND_EVAL_SHADOWED,
-
- // The variable could not be statically resolved and needs to be looked up
- // dynamically. NULL is returned. There are two possible reasons:
- // * A 'with' statement has been encountered and there is no variable
- // binding for the name between the variable reference and the 'with'.
- // The variable potentially references a property of the 'with' object.
- // * The code is being executed as part of a call to 'eval' and the calling
- // context chain contains either a variable binding for the name or it
- // contains a 'with' context.
- DYNAMIC_LOOKUP
- };
-
- // Lookup a variable reference given by name recursively starting with this
- // scope. If the code is executed because of a call to 'eval', the context
- // parameter should be set to the calling context of 'eval'.
Variable* LookupRecursive(Handle<String> name,
- BindingKind* binding_kind,
- AstNodeFactory<AstNullVisitor>* factory);
- MUST_USE_RESULT
- bool ResolveVariable(CompilationInfo* info,
- VariableProxy* proxy,
- AstNodeFactory<AstNullVisitor>* factory);
- MUST_USE_RESULT
- bool ResolveVariablesRecursively(CompilationInfo* info,
- AstNodeFactory<AstNullVisitor>* factory);
+ bool from_inner_function,
+ Variable** invalidated_local);
+ void ResolveVariable(Scope* global_scope,
+ Handle<Context> context,
+ VariableProxy* proxy);
+ void ResolveVariablesRecursively(Scope* global_scope,
+ Handle<Context> context);
// Scope analysis.
- bool PropagateScopeInfo(bool outer_scope_calls_non_strict_eval);
+ bool PropagateScopeInfo(bool outer_scope_calls_eval,
+ bool outer_scope_calls_non_strict_eval,
+ bool outer_scope_is_eval_scope);
bool HasTrivialContext() const;
// Predicates.
@@ -571,21 +437,9 @@
void AllocateNonParameterLocals();
void AllocateVariablesRecursively();
- // Resolve and fill in the allocation information for all variables
- // in this scopes. Must be called *after* all scopes have been
- // processed (parsed) to ensure that unresolved variables can be
- // resolved properly.
- //
- // In the case of code compiled and run using 'eval', the context
- // parameter is the context in which eval was called. In all other
- // cases the context parameter is an empty handle.
- MUST_USE_RESULT
- bool AllocateVariables(CompilationInfo* info,
- AstNodeFactory<AstNullVisitor>* factory);
-
private:
- // Construct a scope based on the scope info.
- Scope(Scope* inner_scope, ScopeType type, Handle<ScopeInfo> scope_info);
+ // Construct a function or block scope based on the scope info.
+ Scope(Scope* inner_scope, Type type, Handle<SerializedScopeInfo> scope_info);
// Construct a catch scope with a binding for the name.
Scope(Scope* inner_scope, Handle<String> catch_variable_name);
@@ -597,9 +451,9 @@
}
}
- void SetDefaults(ScopeType type,
+ void SetDefaults(Type type,
Scope* outer_scope,
- Handle<ScopeInfo> scope_info);
+ Handle<SerializedScopeInfo> scope_info);
};
} } // namespace v8::internal