[turbofan] Allow to reuse OSR code objects.

src/compiler.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/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 715 matching lines @@
 void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
   Handle<Code> code = info->code();
   if (code->kind() != Code::OPTIMIZED_FUNCTION) return;  // Nothing to do.
 
   // Function context specialization folds-in the function context,
   // so no sharing can occur.
   if (info->is_function_context_specializing()) return;
   // Frame specialization implies function context specialization.
   DCHECK(!info->is_frame_specializing());
 
-  // TODO(4764): When compiling for OSR from bytecode, BailoutId might derive
-  // from bytecode offset and overlap with actual BailoutId. No caching!
-  if (info->is_osr() && info->is_optimizing_from_bytecode()) return;
-
   // Cache optimized context-specific code.
   Handle<JSFunction> function = info->closure();
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<Context> native_context(function->context()->native_context());
   SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                             info->osr_ast_id());
 }
 
 bool GetOptimizedCodeNow(CompilationJob* job) {
   CompilationInfo* info = job->info();
@@ skipping 95 matching lines @@
                                    BailoutId osr_ast_id = BailoutId::None(),
                                    JavaScriptFrame* osr_frame = nullptr) {
   Isolate* isolate = function->GetIsolate();
   Handle<SharedFunctionInfo> shared(function->shared(), isolate);
 
   bool ignition_osr = osr_frame && osr_frame->is_interpreted();
   DCHECK_IMPLIES(ignition_osr, !osr_ast_id.IsNone());
   DCHECK_IMPLIES(ignition_osr, FLAG_ignition_osr);
 
   Handle<Code> cached_code;
-  // TODO(4764): When compiling for OSR from bytecode, BailoutId might derive
-  // from bytecode offset and overlap with actual BailoutId. No lookup!
-  if (!ignition_osr &&
-      GetCodeFromOptimizedCodeMap(function, osr_ast_id)
+  if (GetCodeFromOptimizedCodeMap(function, osr_ast_id)
           .ToHandle(&cached_code)) {
     if (FLAG_trace_opt) {
       PrintF("[found optimized code for ");
       function->ShortPrint();
       if (!osr_ast_id.IsNone()) {
         PrintF(" at OSR AST id %d", osr_ast_id.ToInt());
       }
       PrintF("]\n");
     }
     return cached_code;
@@ skipping 43 matching lines @@
     info->AbortOptimization(kDeoptimizedTooManyTimes);
     return MaybeHandle<Code>();
   }
 
   TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
   RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::OptimizeCode);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.OptimizeCode");
 
   // TurboFan can optimize directly from existing bytecode.
   if (use_turbofan && ShouldUseIgnition(info)) {
     if (info->is_osr() && !ignition_osr) return MaybeHandle<Code>();

[Michael Starzinger, 2017/04/06 08:09:42]

Now that --ignition-staging is no more, and the assumption that we never mix OSR
from Ignition and from FullCodegen, we should also be able to remove the bailout
for this corner case. WDYT?

[Benedikt Meurer, 2017/04/06 10:34:55]

Done.

     DCHECK(shared->HasBytecodeArray());
     info->MarkAsOptimizeFromBytecode();
   }
 
   // Verify that OSR compilations are delegated to the correct graph builder.
   // Depending on the underlying frame the semantics of the {BailoutId} differ
   // and the various graph builders hard-code a certain semantic:
   //  - Interpreter : The BailoutId represents a bytecode offset.
   //  - FullCodegen : The BailoutId represents the id of an AST node.
   DCHECK_IMPLIES(info->is_osr() && ignition_osr,
@@ skipping 959 matching lines @@
   }
 
   if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8