From 181d7b85977eb752b19e1de902093783e31330ef Mon Sep 17 00:00:00 2001 From: mstarzinger Date: Thu, 21 May 2015 06:05:48 -0700 Subject: [PATCH] Remove obsolete JSFunction::IsOptimizable predicate. This just delegates to SharedFunctionInfo::optimization_disabled and was primarily used for assertions. Removing it due to misleading name because already optimized functions reported being "non-optimizable". R=titzer@chromium.org Review URL: https://codereview.chromium.org/1150683002 Cr-Commit-Position: refs/heads/master@{#28551} --- src/objects-inl.h | 5 ----- src/objects.cc | 6 +++--- src/objects.h | 3 --- src/runtime-profiler.cc | 4 +--- src/runtime/runtime-test.cc | 6 ++---- test/cctest/test-compiler.cc | 6 ++---- 6 files changed, 8 insertions(+), 22 deletions(-) diff --git a/src/objects-inl.h b/src/objects-inl.h index fea849afaa..aa82b83915 100644 --- a/src/objects-inl.h +++ b/src/objects-inl.h @@ -6022,11 +6022,6 @@ bool JSFunction::IsOptimized() { } -bool JSFunction::IsOptimizable() { - return code()->kind() == Code::FUNCTION && !shared()->optimization_disabled(); -} - - bool JSFunction::IsMarkedForOptimization() { return code() == GetIsolate()->builtins()->builtin( Builtins::kCompileOptimized); diff --git a/src/objects.cc b/src/objects.cc index 24ecc6b50e..8d87ed7391 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -9808,7 +9808,7 @@ void JSFunction::JSFunctionIterateBody(int object_size, ObjectVisitor* v) { void JSFunction::MarkForOptimization() { Isolate* isolate = GetIsolate(); DCHECK(!IsOptimized()); - DCHECK(shared()->allows_lazy_compilation() || IsOptimizable()); + DCHECK(shared()->allows_lazy_compilation()); set_code_no_write_barrier( isolate->builtins()->builtin(Builtins::kCompileOptimized)); // No write barrier required, since the builtin is part of the root set. @@ -9832,7 +9832,7 @@ void JSFunction::AttemptConcurrentOptimization() { } DCHECK(!IsInOptimizationQueue()); DCHECK(!IsOptimized()); - DCHECK(shared()->allows_lazy_compilation() || IsOptimizable()); + DCHECK(shared()->allows_lazy_compilation()); DCHECK(isolate->concurrent_recompilation_enabled()); if (FLAG_trace_concurrent_recompilation) { PrintF(" ** Marking "); @@ -9840,7 +9840,7 @@ void JSFunction::AttemptConcurrentOptimization() { PrintF(" for concurrent recompilation.\n"); } set_code_no_write_barrier( - GetIsolate()->builtins()->builtin(Builtins::kCompileOptimizedConcurrent)); + isolate->builtins()->builtin(Builtins::kCompileOptimizedConcurrent)); // No write barrier required, since the builtin is part of the root set. } diff --git a/src/objects.h b/src/objects.h index 665da0384c..29a1e13789 100644 --- a/src/objects.h +++ b/src/objects.h @@ -7619,9 +7619,6 @@ class JSFunction: public JSObject { // Tells whether or not this function has been optimized. inline bool IsOptimized(); - // Tells whether or not this function can be optimized. - inline bool IsOptimizable(); - // Mark this function for lazy recompilation. The function will be // recompiled the next time it is executed. void MarkForOptimization(); diff --git a/src/runtime-profiler.cc b/src/runtime-profiler.cc index 22567d3b90..838888aeb1 100644 --- a/src/runtime-profiler.cc +++ b/src/runtime-profiler.cc @@ -88,8 +88,6 @@ static void GetICCounts(SharedFunctionInfo* shared, void RuntimeProfiler::Optimize(JSFunction* function, const char* reason) { - DCHECK(function->IsOptimizable()); - if (FLAG_trace_opt && function->PassesFilter(FLAG_hydrogen_filter)) { PrintF("[marking "); function->ShortPrint(); @@ -217,7 +215,7 @@ void RuntimeProfiler::OptimizeNow() { } continue; } - if (!function->IsOptimizable()) continue; + if (function->IsOptimized()) continue; int ticks = shared_code->profiler_ticks(); diff --git a/src/runtime/runtime-test.cc b/src/runtime/runtime-test.cc index e115ba9e24..28f16a4686 100644 --- a/src/runtime/runtime-test.cc +++ b/src/runtime/runtime-test.cc @@ -87,8 +87,7 @@ RUNTIME_FUNCTION(Runtime_OptimizeFunctionOnNextCall) { CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0); // The following assertion was lifted from the DCHECK inside // JSFunction::MarkForOptimization(). - RUNTIME_ASSERT(function->shared()->allows_lazy_compilation() || - function->IsOptimizable()); + RUNTIME_ASSERT(function->shared()->allows_lazy_compilation()); // If the function is already optimized, just return. if (function->IsOptimized()) return isolate->heap()->undefined_value(); @@ -131,8 +130,7 @@ RUNTIME_FUNCTION(Runtime_OptimizeOsr) { // The following assertion was lifted from the DCHECK inside // JSFunction::MarkForOptimization(). - RUNTIME_ASSERT(function->shared()->allows_lazy_compilation() || - function->IsOptimizable()); + RUNTIME_ASSERT(function->shared()->allows_lazy_compilation()); // If the function is already optimized, just return. if (function->IsOptimized()) return isolate->heap()->undefined_value(); diff --git a/test/cctest/test-compiler.cc b/test/cctest/test-compiler.cc index ef09891cb7..57704f9c1e 100644 --- a/test/cctest/test-compiler.cc +++ b/test/cctest/test-compiler.cc @@ -395,10 +395,8 @@ TEST(OptimizedCodeSharing) { *v8::Local::Cast(env->Global()->Get(v8_str("closure1")))); Handle fun2 = v8::Utils::OpenHandle( *v8::Local::Cast(env->Global()->Get(v8_str("closure2")))); - CHECK(fun1->IsOptimized() - || !CcTest::i_isolate()->use_crankshaft() || !fun1->IsOptimizable()); - CHECK(fun2->IsOptimized() - || !CcTest::i_isolate()->use_crankshaft() || !fun2->IsOptimizable()); + CHECK(fun1->IsOptimized() || !CcTest::i_isolate()->use_crankshaft()); + CHECK(fun2->IsOptimized() || !CcTest::i_isolate()->use_crankshaft()); CHECK_EQ(fun1->code(), fun2->code()); } }