From c0d0bf863a148fc82da87a56249ea1448efdf828 Mon Sep 17 00:00:00 2001 From: "keuchel@chromium.org" Date: Mon, 7 Nov 2011 12:33:58 +0000 Subject: [PATCH] Revert r9870 due to browser-test failures. This reverts commit 4d5b5f12aac932ad892c7b6f152b6168708d4210. Review URL: http://codereview.chromium.org/8493006 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9896 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/arm/full-codegen-arm.cc | 72 ++++++++++------------------------- src/ia32/full-codegen-ia32.cc | 70 +++++++++------------------------- src/parser.cc | 7 +--- src/variables.cc | 1 - src/variables.h | 4 -- src/x64/full-codegen-x64.cc | 70 +++++++++------------------------- 6 files changed, 59 insertions(+), 165 deletions(-) diff --git a/src/arm/full-codegen-arm.cc b/src/arm/full-codegen-arm.cc index f19bde73c..adc1b26c6 100644 --- a/src/arm/full-codegen-arm.cc +++ b/src/arm/full-codegen-arm.cc @@ -1283,60 +1283,28 @@ void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) { Comment cmnt(masm_, var->IsContextSlot() ? "Context variable" : "Stack variable"); - if (var->binding_needs_init()) { - // var->scope() may be NULL when the proxy is located in eval code and - // refers to a potential outside binding. Currently those bindings are - // always looked up dynamically, i.e. in that case - // var->location() == LOOKUP. - // always holds. - ASSERT(var->scope() != NULL); - - // Check if the binding really needs an initialization check. The check - // can be skipped in the following situation: we have a LET or CONST - // binding in harmony mode, both the Variable and the VariableProxy have - // the same declaration scope (i.e. they are both in global code, in the - // same function or in the same eval code) and the VariableProxy is in - // the source physically located after the initializer of the variable. - // - // We cannot skip any initialization checks for CONST in non-harmony - // mode because const variables may be declared but never initialized: - // if (false) { const x; }; var y = x; - // - // The condition on the declaration scopes is a conservative check for - // nested functions that access a binding and are called before the - // binding is initialized: - // function() { f(); let x = 1; function f() { x = 2; } } - // - // Check that we always have valid source position. - ASSERT(var->initializer_position() != RelocInfo::kNoPosition); - ASSERT(proxy->position() != RelocInfo::kNoPosition); - bool skip_init_check = - var->mode() != CONST && - var->scope()->DeclarationScope() == scope()->DeclarationScope() && - var->initializer_position() < proxy->position(); - if (!skip_init_check) { - // Let and const need a read barrier. - GetVar(r0, var); - __ CompareRoot(r0, Heap::kTheHoleValueRootIndex); - if (var->mode() == LET || var->mode() == CONST_HARMONY) { - // Throw a reference error when using an uninitialized let/const - // binding in harmony mode. - Label done; - __ b(ne, &done); - __ mov(r0, Operand(var->name())); - __ push(r0); - __ CallRuntime(Runtime::kThrowReferenceError, 1); - __ bind(&done); - } else { - // Uninitalized const bindings outside of harmony mode are unholed. - ASSERT(var->mode() == CONST); - __ LoadRoot(r0, Heap::kUndefinedValueRootIndex, eq); - } - context()->Plug(r0); - break; + if (!var->binding_needs_init()) { + context()->Plug(var); + } else { + // Let and const need a read barrier. + GetVar(r0, var); + __ CompareRoot(r0, Heap::kTheHoleValueRootIndex); + if (var->mode() == LET || var->mode() == CONST_HARMONY) { + // Throw a reference error when using an uninitialized let/const + // binding in harmony mode. + Label done; + __ b(ne, &done); + __ mov(r0, Operand(var->name())); + __ push(r0); + __ CallRuntime(Runtime::kThrowReferenceError, 1); + __ bind(&done); + } else { + // Uninitalized const bindings outside of harmony mode are unholed. + ASSERT(var->mode() == CONST); + __ LoadRoot(r0, Heap::kUndefinedValueRootIndex, eq); } + context()->Plug(r0); } - context()->Plug(var); break; } diff --git a/src/ia32/full-codegen-ia32.cc b/src/ia32/full-codegen-ia32.cc index 2cbf51893..e8108fc7c 100644 --- a/src/ia32/full-codegen-ia32.cc +++ b/src/ia32/full-codegen-ia32.cc @@ -1234,59 +1234,27 @@ void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) { Comment cmnt(masm_, var->IsContextSlot() ? "Context variable" : "Stack variable"); - if (var->binding_needs_init()) { - // var->scope() may be NULL when the proxy is located in eval code and - // refers to a potential outside binding. Currently those bindings are - // always looked up dynamically, i.e. in that case - // var->location() == LOOKUP. - // always holds. - ASSERT(var->scope() != NULL); - - // Check if the binding really needs an initialization check. The check - // can be skipped in the following situation: we have a LET or CONST - // binding in harmony mode, both the Variable and the VariableProxy have - // the same declaration scope (i.e. they are both in global code, in the - // same function or in the same eval code) and the VariableProxy is in - // the source physically located after the initializer of the variable. - // - // We cannot skip any initialization checks for CONST in non-harmony - // mode because const variables may be declared but never initialized: - // if (false) { const x; }; var y = x; - // - // The condition on the declaration scopes is a conservative check for - // nested functions that access a binding and are called before the - // binding is initialized: - // function() { f(); let x = 1; function f() { x = 2; } } - // - // Check that we always have valid source position. - ASSERT(var->initializer_position() != RelocInfo::kNoPosition); - ASSERT(proxy->position() != RelocInfo::kNoPosition); - bool skip_init_check = - var->mode() != CONST && - var->scope()->DeclarationScope() == scope()->DeclarationScope() && - var->initializer_position() < proxy->position(); - if (!skip_init_check) { - // Let and const need a read barrier. - Label done; - GetVar(eax, var); - __ cmp(eax, isolate()->factory()->the_hole_value()); - __ j(not_equal, &done, Label::kNear); - if (var->mode() == LET || var->mode() == CONST_HARMONY) { - // Throw a reference error when using an uninitialized let/const - // binding in harmony mode. - __ push(Immediate(var->name())); - __ CallRuntime(Runtime::kThrowReferenceError, 1); - } else { - // Uninitalized const bindings outside of harmony mode are unholed. - ASSERT(var->mode() == CONST); - __ mov(eax, isolate()->factory()->undefined_value()); - } - __ bind(&done); - context()->Plug(eax); - break; + if (!var->binding_needs_init()) { + context()->Plug(var); + } else { + // Let and const need a read barrier. + Label done; + GetVar(eax, var); + __ cmp(eax, isolate()->factory()->the_hole_value()); + __ j(not_equal, &done, Label::kNear); + if (var->mode() == LET || var->mode() == CONST_HARMONY) { + // Throw a reference error when using an uninitialized let/const + // binding in harmony mode. + __ push(Immediate(var->name())); + __ CallRuntime(Runtime::kThrowReferenceError, 1); + } else { + // Uninitalized const bindings outside of harmony mode are unholed. + ASSERT(var->mode() == CONST); + __ mov(eax, isolate()->factory()->undefined_value()); } + __ bind(&done); + context()->Plug(eax); } - context()->Plug(var); break; } diff --git a/src/parser.cc b/src/parser.cc index c2177bb21..3e85c7a6a 100644 --- a/src/parser.cc +++ b/src/parser.cc @@ -1773,7 +1773,7 @@ Block* Parser::ParseVariableDeclarations( // For let/const declarations in harmony mode, we can also immediately // pre-resolve the proxy because it resides in the same scope as the // declaration. - VariableProxy* proxy = Declare(name, mode, NULL, mode != VAR, CHECK_OK); + Declare(name, mode, NULL, mode != VAR, CHECK_OK); nvars++; if (declaration_scope->num_var_or_const() > kMaxNumFunctionLocals) { ReportMessageAt(scanner().location(), "too_many_variables", @@ -1828,11 +1828,6 @@ Block* Parser::ParseVariableDeclarations( if (decl_props != NULL) *decl_props = kHasInitializers; } - // Record the end position of the initializer. - if (proxy->var() != NULL) { - proxy->var()->set_initializer_position(scanner().location().end_pos); - } - // Make sure that 'const x' and 'let x' initialize 'x' to undefined. if (value == NULL && needs_init) { value = GetLiteralUndefined(); diff --git a/src/variables.cc b/src/variables.cc index aa6a010fa..a636bdad3 100644 --- a/src/variables.cc +++ b/src/variables.cc @@ -66,7 +66,6 @@ Variable::Variable(Scope* scope, kind_(kind), location_(UNALLOCATED), index_(-1), - initializer_position_(RelocInfo::kNoPosition), local_if_not_shadowed_(NULL), is_valid_LHS_(is_valid_LHS), force_context_allocation_(false), diff --git a/src/variables.h b/src/variables.h index f20bd399c..be86bd197 100644 --- a/src/variables.h +++ b/src/variables.h @@ -103,9 +103,6 @@ class Variable: public ZoneObject { bool is_used() { return is_used_; } void set_is_used(bool flag) { is_used_ = flag; } - int initializer_position() { return initializer_position_; } - void set_initializer_position(int pos) { initializer_position_ = pos; } - bool IsVariable(Handle n) const { return !is_this() && name().is_identical_to(n); } @@ -168,7 +165,6 @@ class Variable: public ZoneObject { Kind kind_; Location location_; int index_; - int initializer_position_; // If this field is set, this variable references the stored locally bound // variable, but it might be shadowed by variable bindings introduced by diff --git a/src/x64/full-codegen-x64.cc b/src/x64/full-codegen-x64.cc index f9186c713..a80a8b792 100644 --- a/src/x64/full-codegen-x64.cc +++ b/src/x64/full-codegen-x64.cc @@ -1240,59 +1240,27 @@ void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) { case Variable::LOCAL: case Variable::CONTEXT: { Comment cmnt(masm_, var->IsContextSlot() ? "Context slot" : "Stack slot"); - if (var->binding_needs_init()) { - // var->scope() may be NULL when the proxy is located in eval code and - // refers to a potential outside binding. Currently those bindings are - // always looked up dynamically, i.e. in that case - // var->location() == LOOKUP. - // always holds. - ASSERT(var->scope() != NULL); - - // Check if the binding really needs an initialization check. The check - // can be skipped in the following situation: we have a LET or CONST - // binding in harmony mode, both the Variable and the VariableProxy have - // the same declaration scope (i.e. they are both in global code, in the - // same function or in the same eval code) and the VariableProxy is in - // the source physically located after the initializer of the variable. - // - // We cannot skip any initialization checks for CONST in non-harmony - // mode because const variables may be declared but never initialized: - // if (false) { const x; }; var y = x; - // - // The condition on the declaration scopes is a conservative check for - // nested functions that access a binding and are called before the - // binding is initialized: - // function() { f(); let x = 1; function f() { x = 2; } } - // - // Check that we always have valid source position. - ASSERT(var->initializer_position() != RelocInfo::kNoPosition); - ASSERT(proxy->position() != RelocInfo::kNoPosition); - bool skip_init_check = - var->mode() != CONST && - var->scope()->DeclarationScope() == scope()->DeclarationScope() && - var->initializer_position() < proxy->position(); - if (!skip_init_check) { - // Let and const need a read barrier. - Label done; - GetVar(rax, var); - __ CompareRoot(rax, Heap::kTheHoleValueRootIndex); - __ j(not_equal, &done, Label::kNear); - if (var->mode() == LET || var->mode() == CONST_HARMONY) { - // Throw a reference error when using an uninitialized let/const - // binding in harmony mode. - __ Push(var->name()); - __ CallRuntime(Runtime::kThrowReferenceError, 1); - } else { - // Uninitalized const bindings outside of harmony mode are unholed. - ASSERT(var->mode() == CONST); - __ LoadRoot(rax, Heap::kUndefinedValueRootIndex); - } - __ bind(&done); - context()->Plug(rax); - break; + if (!var->binding_needs_init()) { + context()->Plug(var); + } else { + // Let and const need a read barrier. + Label done; + GetVar(rax, var); + __ CompareRoot(rax, Heap::kTheHoleValueRootIndex); + __ j(not_equal, &done, Label::kNear); + if (var->mode() == LET || var->mode() == CONST_HARMONY) { + // Throw a reference error when using an uninitialized let/const + // binding in harmony mode. + __ Push(var->name()); + __ CallRuntime(Runtime::kThrowReferenceError, 1); + } else { + // Uninitalized const bindings outside of harmony mode are unholed. + ASSERT(var->mode() == CONST); + __ LoadRoot(rax, Heap::kUndefinedValueRootIndex); } + __ bind(&done); + context()->Plug(rax); } - context()->Plug(var); break; } -- 2.34.1