Cache optimized code for OSR.

src/compiler.cc

 // Copyright 2012 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
@@ skipping 1010 matching lines @@
 
   // Set the expected number of properties for instances and return
   // the resulting function.
   SetExpectedNofPropertiesFromEstimate(result,
                                        literal->expected_property_count());
   live_edit_tracker.RecordFunctionInfo(result, literal, info.zone());
   return result;
 }
 
 
-static Handle<Code> GetCodeFromOptimizedCodeMap(Handle<JSFunction> function) {
+static Handle<Code> GetCodeFromOptimizedCodeMap(Handle<JSFunction> function,
+                                                BailoutId osr_ast_id) {
   if (FLAG_cache_optimized_code) {
     Handle<SharedFunctionInfo> shared(function->shared());
     DisallowHeapAllocation no_gc;
     int index = shared->SearchOptimizedCodeMap(
-        function->context()->native_context());
+        function->context()->native_context(), osr_ast_id);
     if (index > 0) {
       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");
       }
       FixedArray* literals = shared->GetLiteralsFromOptimizedCodeMap(index);
       if (literals != NULL) function->set_literals(literals);
       return Handle<Code>(shared->GetCodeFromOptimizedCodeMap(index));
     }
   }
   return Handle<Code>::null();
 }
 
 
 static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
   Handle<Code> code = info->code();
   if (code->kind() != Code::OPTIMIZED_FUNCTION) return;  // Nothing to do.
 
-  // Cache non-OSR optimized code.
-  if (FLAG_cache_optimized_code && !info->is_osr()) {
+  // Cache optimized code.
+  if (FLAG_cache_optimized_code) {
     Handle<JSFunction> function = info->closure();
     Handle<SharedFunctionInfo> shared(function->shared());
     Handle<FixedArray> literals(function->literals());
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(
-        shared, native_context, code, literals);
+        shared, native_context, code, literals, info->osr_ast_id());
   }
 }
 
 
 static bool CompileOptimizedPrologue(CompilationInfo* info) {
   if (!Parser::Parse(info)) return false;
   LanguageMode language_mode = info->function()->language_mode();
   info->SetLanguageMode(language_mode);
 
   if (!Rewriter::Rewrite(info)) return false;
@@ skipping 56 matching lines @@
     }
   }
   return true;
 }
 
 
 Handle<Code> Compiler::GetOptimizedCode(Handle<JSFunction> function,
                                         Handle<Code> current_code,
                                         ConcurrencyMode mode,
                                         BailoutId osr_ast_id) {
-  if (osr_ast_id.IsNone()) {  // No cache for OSR.
-    Handle<Code> cached_code = GetCodeFromOptimizedCodeMap(function);
-    if (!cached_code.is_null()) return cached_code;
-  }
+  Handle<Code> cached_code = GetCodeFromOptimizedCodeMap(function, osr_ast_id);
+  if (!cached_code.is_null()) return cached_code;
 
   SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(function));
   Isolate* isolate = info->isolate();
   VMState<COMPILER> state(isolate);
   ASSERT(!isolate->has_pending_exception());
   PostponeInterruptsScope postpone(isolate);
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
   ASSERT_NE(ScopeInfo::Empty(isolate), shared->scope_info());
   int compiled_size = shared->end_position() - shared->start_position();
@@ skipping 49 matching lines @@
     return Handle<Code>::null();
   }
 
   if (job->GenerateCode() != OptimizedCompileJob::SUCCEEDED) {
     return Handle<Code>::null();
   }
 
   Compiler::RecordFunctionCompilation(
       Logger::LAZY_COMPILE_TAG, info.get(), shared);
   if (info->shared_info()->SearchOptimizedCodeMap(
-          info->context()->native_context()) == -1) {
+          info->context()->native_context(), info->osr_ast_id()) == -1) {
     InsertCodeIntoOptimizedCodeMap(info.get());
   }
 
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Optimized code for ");
     info->closure()->PrintName();
     PrintF(" generated.\n");
   }
 
   return Handle<Code>(*info->code());
@@ skipping 58 matching lines @@
   AllowHandleDereference allow_deref;
   bool tracing_on = info()->IsStub()
       ? FLAG_trace_hydrogen_stubs
       : (FLAG_trace_hydrogen &&
          info()->closure()->PassesFilter(FLAG_trace_hydrogen_filter));
   return (tracing_on &&
       OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL);
 }
 
 } }  // namespace v8::internal