Reviewers: Kevin Millikin,
Description:
Clear exceptions set during attempts to lazily optimize.
Resubmit of patch for issue 1145 with a few additions:
- Now also clears exceptions when calling Runtime_LazyRecompile.
- Sets function where parsing fails to not be optimizable.
BUG=v8:1145
TEST=test/mjsunit/regress/regress-1145.js
Please review this at http://codereview.chromium.org/6469050/
SVN Base: https://v8.googlecode.com/svn/branches/bleeding_edge/build-ia32
Affected files:
M src/handles.h
M src/handles.cc
M src/hydrogen.cc
M src/objects.cc
M src/runtime.cc
A test/mjsunit/regress/regress-1145.js
Index: src/handles.cc
diff --git a/src/handles.cc b/src/handles.cc
index
d625d644c776e744251d69bfc7f582b77751c1b2..ee1c2bece71d92b33f3502367c37e25fbb221784
100644
--- a/src/handles.cc
+++ b/src/handles.cc
@@ -871,10 +871,12 @@ bool CompileLazyInLoop(Handle<JSFunction> function,
}
-bool CompileOptimized(Handle<JSFunction> function, int osr_ast_id) {
+bool CompileOptimized(Handle<JSFunction> function,
+ int osr_ast_id,
+ ClearExceptionFlag flag) {
CompilationInfo info(function);
info.SetOptimizing(osr_ast_id);
- bool result = CompileLazyHelper(&info, KEEP_EXCEPTION);
+ bool result = CompileLazyHelper(&info, flag);
if (result) PROFILE(FunctionCreateEvent(*function));
return result;
}
Index: src/handles.h
diff --git a/src/handles.h b/src/handles.h
index
d95ca9117022d8d33c3bdfc5cc9dc32c8e7762e5..dfdc2626029dce238613f2042c119db3c6d77c44
100644
--- a/src/handles.h
+++ b/src/handles.h
@@ -354,7 +354,9 @@ bool CompileLazy(Handle<JSFunction> function,
ClearExceptionFlag flag);
bool CompileLazyInLoop(Handle<JSFunction> function, ClearExceptionFlag
flag);
-bool CompileOptimized(Handle<JSFunction> function, int osr_ast_id);
+bool CompileOptimized(Handle<JSFunction> function,
+ int osr_ast_id,
+ ClearExceptionFlag flag);
class NoHandleAllocation BASE_EMBEDDED {
public:
Index: src/hydrogen.cc
diff --git a/src/hydrogen.cc b/src/hydrogen.cc
index
fd5ad728ecb8fef338dda36e378251bfe68dd911..6f57a9f88df89fae9158cb89b00e32309d6b38a5
100644
--- a/src/hydrogen.cc
+++ b/src/hydrogen.cc
@@ -4020,6 +4020,8 @@ bool HGraphBuilder::TryInline(Call* expr) {
!Scope::Analyze(&inner_info)) {
if (Top::has_pending_exception()) {
SetStackOverflow();
+ // Stop trying to optimize and inline this function.
+ target->shared()->set_optimization_disabled(true);
}
return false;
}
Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index
e0232d58732ed014333c6118af88e3ec2645c6d9..03bac65aedea15782dc54d31c639ddf9d3d026bd
100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -5470,9 +5470,11 @@ uint32_t JSFunction::SourceHash() {
bool JSFunction::IsInlineable() {
if (IsBuiltin()) return false;
+ SharedFunctionInfo* shared_info = shared();
// Check that the function has a script associated with it.
- if (!shared()->script()->IsScript()) return false;
- Code* code = shared()->code();
+ if (!shared_info->script()->IsScript()) return false;
+ if (shared_info->optimization_disabled()) return false;
+ Code* code = shared_info->code();
if (code->kind() == Code::OPTIMIZED_FUNCTION) return true;
// If we never ran this (unlikely) then lets try to optimize it.
if (code->kind() != Code::FUNCTION) return true;
Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc
index
2a503e3cebf18c7bc8752bceba57a3ed83961e53..97183587378520eebe8d8c423ff94a8695a98535
100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -7017,7 +7017,7 @@ static MaybeObject* Runtime_LazyRecompile(Arguments
args) {
function->ReplaceCode(function->shared()->code());
return function->code();
}
- if (CompileOptimized(function, AstNode::kNoNumber)) {
+ if (CompileOptimized(function, AstNode::kNoNumber, CLEAR_EXCEPTION)) {
return function->code();
}
if (FLAG_trace_opt) {
@@ -7026,7 +7026,7 @@ static MaybeObject* Runtime_LazyRecompile(Arguments
args) {
PrintF(": optimized compilation failed]\n");
}
function->ReplaceCode(function->shared()->code());
- return Failure::Exception();
+ return function->code();
}
@@ -7186,7 +7186,8 @@ static MaybeObject*
Runtime_CompileForOnStackReplacement(Arguments args) {
// Try to compile the optimized code. A true return value from
// CompileOptimized means that compilation succeeded, not necessarily
// that optimization succeeded.
- if (CompileOptimized(function, ast_id) && function->IsOptimized()) {
+ if (CompileOptimized(function, ast_id, CLEAR_EXCEPTION) &&
+ function->IsOptimized()) {
DeoptimizationInputData* data = DeoptimizationInputData::cast(
function->code()->deoptimization_data());
if (data->OsrPcOffset()->value() >= 0) {
@@ -7229,6 +7230,9 @@ static MaybeObject*
Runtime_CompileForOnStackReplacement(Arguments args) {
ASSERT(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
return Smi::FromInt(ast_id);
} else {
+ if (function->IsMarkedForLazyRecompilation()) {
+ function->ReplaceCode(function->shared()->code());
+ }
return Smi::FromInt(-1);
}
}
Index: test/mjsunit/regress/regress-1145.js
diff --git a/test/mjsunit/regress/regress-1145.js
b/test/mjsunit/regress/regress-1145.js
new file mode 100644
index
0000000000000000000000000000000000000000..5267e90006480caeecc3bbf703678d59c280dda8
--- /dev/null
+++ b/test/mjsunit/regress/regress-1145.js
@@ -0,0 +1,54 @@
+// 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:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided
+// with the distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --opt-eagerly --debug-code
+
+// See: http://code.google.com/p/v8/issues/detail?id=1145
+// Should not throw a syntax error exception (change this if we make
lazily.
+// compiled functions with syntax errors into early errors).
+// Should not hit an assertion in debug mode.
+
+// A lazily compiled function with a syntax error that is attempted inlined
+// would set a pending exception that is then ignored (until it triggers
+// an assert).
+// This file must be at least 1024 bytes long to trigger lazy compilation.
+
+function f() { return 1; }
+
+// Must be lazy. Must throw SyntaxError during compilation.
+function fail() { continue; }
+
+function opt_me() {
+ var x = 1;
+ // Do lots of function calls and hope to be optimized.
+ for (var i = 0; i < 1000000; i++) {
+ x = f();
+ }
+ if (x == 0) fail(); // Hope to be inlined during optimization.
+}
+
+opt_me();
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
