Cache optimized code on shared function info.

src/compiler.cc

 // 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
@@ skipping 566 matching lines @@
       // eval("'use strict'; ...");
       ASSERT(strict_mode == kNonStrictMode || result->strict_mode());
       compilation_cache->PutEval(source, context, is_global, result);
     }
   }
 
   return result;
 }
 
 
+static void AddToOptimizedCodeMap(Handle<SharedFunctionInfo> shared,
+                                  Handle<Context> global_context,
+                                  Handle<Code> code) {
+  ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION);
+  ASSERT(global_context->IsGlobalContext());
+
+  Object* value = shared->optimized_code_map();
+  Handle<FixedArray> new_map;
+  if (value->IsSmi()) {
+    // No optimized code map.
+    ASSERT_EQ(0, Smi::cast(value)->value());
+    new_map = FACTORY->NewFixedArray(2);
+    new_map->set(0, *global_context);
+    new_map->set(1, *code);
+  } else {
+    Handle<FixedArray> old_map(FixedArray::cast(value));
+    ASSERT_EQ(NULL, shared->SearchOptimizedCodeMap(*global_context));
+    int old_length = old_map->length();
+    int new_length = old_length + 2;
+    new_map = FACTORY->NewFixedArray(new_length);
+    for (int i = 0; i < old_length; i += 2) {
+      new_map->set(i, old_map->get(i));
+      new_map->set(i + 1, old_map->get(i + 1));
+    }
+    new_map->set(old_length, *global_context);
+    new_map->set(old_length + 1, *code);
+  }
+#ifdef DEBUG
+  for (int i = 0; i < new_map->length(); i += 2) {
+    ASSERT(new_map->get(i)->IsGlobalContext());
+    ASSERT(new_map->get(i + 1)->IsCode());
+    ASSERT(Code::cast(new_map->get(i + 1))->kind() == Code::OPTIMIZED_FUNCTION);
+  }
+#endif
+  shared->set_optimized_code_map(*new_map);
+}
+
+
 bool Compiler::CompileLazy(CompilationInfo* info) {
   CompilationZoneScope zone_scope(DELETE_ON_EXIT);
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(info->isolate(), COMPILER);
 
   Isolate* isolate = info->isolate();
   PostponeInterruptsScope postpone(isolate);
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
   int compiled_size = shared->end_position() - shared->start_position();
   isolate->counters()->total_compile_size()->Increment(compiled_size);
 
+  if (FLAG_cache_optimized_code
+      && info->IsOptimizing() && info->osr_ast_id() == -1) {
+    Handle<JSFunction> function = info->closure();
+    ASSERT(!function.is_null());
+    Handle<Context> global_context(function->context()->global_context());
+    Code* code = function->shared()->SearchOptimizedCodeMap(*global_context);
+    if (code != NULL) {
+      function->ReplaceCode(code);
+      return true;
+    }
+  }
+
   // Generate the AST for the lazily compiled function.
   if (ParserApi::Parse(info)) {
     // Measure how long it takes to do the lazy compilation; only take the
     // rest of the function into account to avoid overlap with the lazy
     // parsing statistics.
     HistogramTimerScope timer(isolate->counters()->compile_lazy());
 
     // Compile the code.
     if (!MakeCode(info)) {
       if (!isolate->has_pending_exception()) {
         isolate->StackOverflow();
       }
     } else {
       ASSERT(!info->code().is_null());
       Handle<Code> code = info->code();
       // Set optimizable to false if this is disallowed by the shared
       // function info, e.g., we might have flushed the code and must
       // reset this bit when lazy compiling the code again.
       if (shared->optimization_disabled()) code->set_optimizable(false);
 
       Handle<JSFunction> function = info->closure();
       RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info, shared);
 
       if (info->IsOptimizing()) {
         function->ReplaceCode(*code);
+        if (FLAG_cache_optimized_code
+            && code->kind() == Code::OPTIMIZED_FUNCTION
+            && info->osr_ast_id() == -1) {
+          Handle<SharedFunctionInfo> shared(function->shared());
+          Handle<Context> global_context(function->context()->global_context());
+          AddToOptimizedCodeMap(shared, global_context, code);
+        }
       } else {
         // Update the shared function info with the compiled code and the
         // scope info.  Please note, that the order of the shared function
         // info initialization is important since set_scope_info might
         // trigger a GC, causing the ASSERT below to be invalid if the code
         // was flushed. By settting the code object last we avoid this.
         Handle<SerializedScopeInfo> scope_info =
             SerializedScopeInfo::Create(info->scope());
         shared->set_scope_info(*scope_info);
         shared->set_code(*code);
@@ skipping 148 matching lines @@
                               shared->DebugName()));
     }
   }
 
   GDBJIT(AddCode(name,
                  Handle<Script>(info->script()),
                  Handle<Code>(info->code())));
 }
 
 } }  // namespace v8::internal