[interpreter] Fix profiler when hitting OSR frame.

src/runtime-profiler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/runtime-profiler.h"
 
 #include "src/assembler.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 246 matching lines @@
         generic_percentage <= FLAG_generic_ic_threshold) {
       Optimize(function, "small function");
     } else {
       shared_code->set_profiler_ticks(ticks + 1);
     }
   } else {
     shared_code->set_profiler_ticks(ticks + 1);
   }
 }
 
-void RuntimeProfiler::MaybeBaselineIgnition(JSFunction* function) {
+void RuntimeProfiler::MaybeBaselineIgnition(JSFunction* function,
+                                            bool frame_optimized) {
   if (function->IsInOptimizationQueue()) return;
 
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
   // TODO(rmcilroy): Also ensure we only OSR top-level code if it is smaller
   // than kMaxToplevelSourceSize.
 
   if (FLAG_ignition_osr && FLAG_always_osr) {
     AttemptOnStackReplacement(function, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal baseline compile as well.
-  } else if (function->IsMarkedForBaseline() ||
-             function->IsMarkedForOptimization() ||
-             function->IsMarkedForConcurrentOptimization() ||
-             function->IsOptimized()) {
+  } else if (!frame_optimized &&
+             (function->IsMarkedForBaseline() ||
+              function->IsMarkedForOptimization() ||
+              function->IsMarkedForConcurrentOptimization() ||
+              function->IsOptimized())) {
     // Attempt OSR if we are still running interpreted code even though the
     // the function has long been marked or even already been optimized.
     int64_t allowance =
         kOSRCodeSizeAllowanceBaseIgnition +
         static_cast<int64_t>(ticks) * kOSRCodeSizeAllowancePerTickIgnition;
     if (FLAG_ignition_osr && shared->HasBytecodeArray() &&
         shared->bytecode_array()->Size() <= allowance) {
       AttemptOnStackReplacement(function);
     }
     return;
   }
 
   if (shared->optimization_disabled() &&
       shared->disable_optimization_reason() == kOptimizationDisabledForTest) {
     // Don't baseline functions which have been marked by NeverOptimizeFunction
     // in a test.
     return;
   }
 
   if (ticks >= kProfilerTicksBeforeBaseline) {
     Baseline(function, "hot enough for baseline");
   }
 }
 
-void RuntimeProfiler::MaybeOptimizeIgnition(JSFunction* function) {
+void RuntimeProfiler::MaybeOptimizeIgnition(JSFunction* function,
+                                            bool frame_optimized) {
   if (function->IsInOptimizationQueue()) return;
 
   SharedFunctionInfo* shared = function->shared();
   int ticks = shared->profiler_ticks();
 
   // TODO(rmcilroy): Also ensure we only OSR top-level code if it is smaller
   // than kMaxToplevelSourceSize.
 
   if (FLAG_ignition_osr && FLAG_always_osr) {
     AttemptOnStackReplacement(function, AbstractCode::kMaxLoopNestingMarker);
     // Fall through and do a normal optimized compile as well.
-  } else if (function->IsMarkedForBaseline() ||
-             function->IsMarkedForOptimization() ||
-             function->IsMarkedForConcurrentOptimization() ||
-             function->IsOptimized()) {
+  } else if (!frame_optimized &&
+             (function->IsMarkedForBaseline() ||
+              function->IsMarkedForOptimization() ||
+              function->IsMarkedForConcurrentOptimization() ||
+              function->IsOptimized())) {
     // Attempt OSR if we are still running interpreted code even though the
     // the function has long been marked or even already been optimized.
     int64_t allowance =
         kOSRCodeSizeAllowanceBaseIgnition +
         static_cast<int64_t>(ticks) * kOSRCodeSizeAllowancePerTickIgnition;
     if (FLAG_ignition_osr && shared->HasBytecodeArray() &&
         shared->bytecode_array()->Size() <= allowance) {
       AttemptOnStackReplacement(function);
     }
     return;
@@ skipping 59 matching lines @@
     for (int i = functions.length(); --i >= 0; ) {
       SharedFunctionInfo* shared_function_info = functions[i]->shared();
       int ticks = shared_function_info->profiler_ticks();
       if (ticks < Smi::kMaxValue) {
         shared_function_info->set_profiler_ticks(ticks + 1);
       }
     }
 
     Compiler::CompilationTier next_tier =
         Compiler::NextCompilationTier(function);
-    if (frame->is_interpreted()) {
+    if (function->shared()->HasBytecodeArray()) {
       if (next_tier == Compiler::BASELINE) {
-        DCHECK(!frame->is_optimized());
-        MaybeBaselineIgnition(function);
+        MaybeBaselineIgnition(function, frame->is_optimized());
       } else {
         DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
-        MaybeOptimizeIgnition(function);
+        MaybeOptimizeIgnition(function, frame->is_optimized());
       }
     } else {
       DCHECK_EQ(next_tier, Compiler::OPTIMIZED);
       MaybeOptimizeFullCodegen(function, frame_count, frame->is_optimized());
     }
   }
   any_ic_changed_ = false;
 }
 
 
 }  // namespace internal
 }  // namespace v8