From: jkummerow@chromium.org Date: Mon, 30 Sep 2013 17:42:58 +0000 (+0000) Subject: Revert "Defer allocation of native function literals." X-Git-Tag: upstream/4.7.83~12241 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=85ae341b09fe74dcb531a494dbbde0a0aee49d2e;p=platform%2Fupstream%2Fv8.git Revert "Defer allocation of native function literals." This reverts r17017 for breaking LayoutTests. R=mstarzinger@chromium.org TBR=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/25315002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@17024 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/ast.cc b/src/ast.cc index b98d2a6..5f085d3 100644 --- a/src/ast.cc +++ b/src/ast.cc @@ -1143,7 +1143,7 @@ DONT_OPTIMIZE_NODE(WithStatement) DONT_OPTIMIZE_NODE(TryCatchStatement) DONT_OPTIMIZE_NODE(TryFinallyStatement) DONT_OPTIMIZE_NODE(DebuggerStatement) -DONT_OPTIMIZE_NODE(NativeFunctionLiteral) +DONT_OPTIMIZE_NODE(SharedFunctionInfoLiteral) DONT_SELFOPTIMIZE_NODE(DoWhileStatement) DONT_SELFOPTIMIZE_NODE(WhileStatement) diff --git a/src/ast.h b/src/ast.h index 5c98064..71a51ab 100644 --- a/src/ast.h +++ b/src/ast.h @@ -97,7 +97,7 @@ namespace internal { #define EXPRESSION_NODE_LIST(V) \ V(FunctionLiteral) \ - V(NativeFunctionLiteral) \ + V(SharedFunctionInfoLiteral) \ V(Conditional) \ V(VariableProxy) \ V(Literal) \ @@ -2380,18 +2380,23 @@ class FunctionLiteral V8_FINAL : public Expression { }; -class NativeFunctionLiteral V8_FINAL : public Expression { +class SharedFunctionInfoLiteral V8_FINAL : public Expression { public: - DECLARE_NODE_TYPE(NativeFunctionLiteral) + DECLARE_NODE_TYPE(SharedFunctionInfoLiteral) - Handle name() const { return name_; } + Handle shared_function_info() const { + return shared_function_info_; + } protected: - NativeFunctionLiteral(Isolate* isolate, Handle name) - : Expression(isolate), name_(name) { } + SharedFunctionInfoLiteral( + Isolate* isolate, + Handle shared_function_info) + : Expression(isolate), + shared_function_info_(shared_function_info) { } private: - Handle name_; + Handle shared_function_info_; }; @@ -3232,10 +3237,11 @@ class AstNodeFactory V8_FINAL BASE_EMBEDDED { return lit; } - NativeFunctionLiteral* NewNativeFunctionLiteral(Handle name) { - NativeFunctionLiteral* lit = - new(zone_) NativeFunctionLiteral(isolate_, name); - VISIT_AND_RETURN(NativeFunctionLiteral, lit) + SharedFunctionInfoLiteral* NewSharedFunctionInfoLiteral( + Handle shared_function_info) { + SharedFunctionInfoLiteral* lit = + new(zone_) SharedFunctionInfoLiteral(isolate_, shared_function_info); + VISIT_AND_RETURN(SharedFunctionInfoLiteral, lit) } ThisFunction* NewThisFunction() { diff --git a/src/full-codegen.cc b/src/full-codegen.cc index 308805a..c4ae1d7 100644 --- a/src/full-codegen.cc +++ b/src/full-codegen.cc @@ -197,8 +197,8 @@ void BreakableStatementChecker::VisitFunctionLiteral(FunctionLiteral* expr) { } -void BreakableStatementChecker::VisitNativeFunctionLiteral( - NativeFunctionLiteral* expr) { +void BreakableStatementChecker::VisitSharedFunctionInfoLiteral( + SharedFunctionInfoLiteral* expr) { } @@ -1567,33 +1567,10 @@ void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) { } -void FullCodeGenerator::VisitNativeFunctionLiteral( - NativeFunctionLiteral* expr) { - Comment cmnt(masm_, "[ NativeFunctionLiteral"); - - // Compute the function template for the native function. - Handle name = expr->name(); - v8::Handle fun_template = - info_->extension()->GetNativeFunction(v8::Utils::ToLocal(name)); - ASSERT(!fun_template.IsEmpty()); - - // Instantiate the function and create a shared function info from it. - Handle fun = Utils::OpenHandle(*fun_template->GetFunction()); - const int literals = fun->NumberOfLiterals(); - Handle code = Handle(fun->shared()->code()); - Handle construct_stub = Handle(fun->shared()->construct_stub()); - bool is_generator = false; - Handle shared = - isolate()->factory()->NewSharedFunctionInfo(name, literals, is_generator, - code, Handle(fun->shared()->scope_info())); - shared->set_construct_stub(*construct_stub); - - // Copy the function data to the shared function info. - shared->set_function_data(fun->shared()->function_data()); - int parameters = fun->shared()->formal_parameter_count(); - shared->set_formal_parameter_count(parameters); - - EmitNewClosure(shared, false); +void FullCodeGenerator::VisitSharedFunctionInfoLiteral( + SharedFunctionInfoLiteral* expr) { + Comment cmnt(masm_, "[ SharedFunctionInfoLiteral"); + EmitNewClosure(expr->shared_function_info(), false); } diff --git a/src/hydrogen.cc b/src/hydrogen.cc index 4d31a2f..b7d1756 100644 --- a/src/hydrogen.cc +++ b/src/hydrogen.cc @@ -3983,12 +3983,12 @@ void HOptimizedGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) { } -void HOptimizedGraphBuilder::VisitNativeFunctionLiteral( - NativeFunctionLiteral* expr) { +void HOptimizedGraphBuilder::VisitSharedFunctionInfoLiteral( + SharedFunctionInfoLiteral* expr) { ASSERT(!HasStackOverflow()); ASSERT(current_block() != NULL); ASSERT(current_block()->HasPredecessor()); - return Bailout(kNativeFunctionLiteral); + return Bailout(kSharedFunctionInfoLiteral); } diff --git a/src/objects.h b/src/objects.h index 128948a..8a48116 100644 --- a/src/objects.h +++ b/src/objects.h @@ -1206,7 +1206,6 @@ class MaybeObject BASE_EMBEDDED { V(kModuleStatement, "Module statement") \ V(kModuleVariable, "Module variable") \ V(kModuleUrl, "Module url") \ - V(kNativeFunctionLiteral, "Native function literal") \ V(kNoCasesLeft, "no cases left") \ V(kNoEmptyArraysHereInEmitFastAsciiArrayJoin, \ "No empty arrays here in EmitFastAsciiArrayJoin") \ @@ -1250,6 +1249,7 @@ class MaybeObject BASE_EMBEDDED { V(kRegisterDidNotMatchExpectedRoot, "Register did not match expected root") \ V(kRegisterWasClobbered, "register was clobbered") \ V(kScopedBlock, "ScopedBlock") \ + V(kSharedFunctionInfoLiteral, "Shared function info literal") \ V(kSmiAdditionOverflow, "Smi addition overflow") \ V(kSmiSubtractionOverflow, "Smi subtraction overflow") \ V(kStackFrameTypesMustMatch, "stack frame types must match") \ diff --git a/src/parser.cc b/src/parser.cc index 09d89f9..05ae11e 100644 --- a/src/parser.cc +++ b/src/parser.cc @@ -1667,6 +1667,27 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) { // because of lazy compilation. DeclarationScope(VAR)->ForceEagerCompilation(); + // Compute the function template for the native function. + v8::Handle fun_template = + extension_->GetNativeFunction(v8::Utils::ToLocal(name)); + ASSERT(!fun_template.IsEmpty()); + + // Instantiate the function and create a shared function info from it. + Handle fun = Utils::OpenHandle(*fun_template->GetFunction()); + const int literals = fun->NumberOfLiterals(); + Handle code = Handle(fun->shared()->code()); + Handle construct_stub = Handle(fun->shared()->construct_stub()); + bool is_generator = false; + Handle shared = + isolate()->factory()->NewSharedFunctionInfo(name, literals, is_generator, + code, Handle(fun->shared()->scope_info())); + shared->set_construct_stub(*construct_stub); + + // Copy the function data to the shared function info. + shared->set_function_data(fun->shared()->function_data()); + int parameters = fun->shared()->formal_parameter_count(); + shared->set_formal_parameter_count(parameters); + // TODO(1240846): It's weird that native function declarations are // introduced dynamically when we meet their declarations, whereas // other functions are set up when entering the surrounding scope. @@ -1674,7 +1695,8 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) { Declaration* declaration = factory()->NewVariableDeclaration(proxy, VAR, top_scope_); Declare(declaration, true, CHECK_OK); - NativeFunctionLiteral* lit = factory()->NewNativeFunctionLiteral(name); + SharedFunctionInfoLiteral* lit = + factory()->NewSharedFunctionInfoLiteral(shared); return factory()->NewExpressionStatement( factory()->NewAssignment( Token::INIT_VAR, proxy, lit, RelocInfo::kNoPosition)); diff --git a/src/prettyprinter.cc b/src/prettyprinter.cc index 14ad707..b1bac4c 100644 --- a/src/prettyprinter.cc +++ b/src/prettyprinter.cc @@ -297,9 +297,10 @@ void PrettyPrinter::VisitFunctionLiteral(FunctionLiteral* node) { } -void PrettyPrinter::VisitNativeFunctionLiteral(NativeFunctionLiteral* node) { +void PrettyPrinter::VisitSharedFunctionInfoLiteral( + SharedFunctionInfoLiteral* node) { Print("("); - PrintLiteral(node->name(), false); + PrintLiteral(node->shared_function_info(), true); Print(")"); } @@ -981,9 +982,10 @@ void AstPrinter::VisitFunctionLiteral(FunctionLiteral* node) { } -void AstPrinter::VisitNativeFunctionLiteral(NativeFunctionLiteral* node) { - IndentedScope indent(this, "NATIVE FUNC LITERAL"); - PrintLiteralIndented("NAME", node->name(), false); +void AstPrinter::VisitSharedFunctionInfoLiteral( + SharedFunctionInfoLiteral* node) { + IndentedScope indent(this, "FUNC LITERAL"); + PrintLiteralIndented("SHARED INFO", node->shared_function_info(), true); } diff --git a/src/typing.cc b/src/typing.cc index 3fd1ce5..34bb64b 100644 --- a/src/typing.cc +++ b/src/typing.cc @@ -305,7 +305,7 @@ void AstTyper::VisitFunctionLiteral(FunctionLiteral* expr) { } -void AstTyper::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) { +void AstTyper::VisitSharedFunctionInfoLiteral(SharedFunctionInfoLiteral* expr) { }