Share optimized code for closures.

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 596 matching lines @@
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(isolate, COMPILER);
 
   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()) {
+    Handle<JSFunction> function = info->closure();
+    ASSERT(!function.is_null());
+    Handle<Context> global_context(function->context()->global_context());
+    int index = function->shared()->SearchOptimizedCodeMap(*global_context);
+    if (index > 0) {
+      if (FLAG_trace_opt) {
+        PrintF("  [Found optimized code for");
+        function->PrintName();
+        PrintF("\n");
+      }
+      Code* code = Code::cast(
+          FixedArray::cast(shared->optimized_code_map())->get(index));
+      ASSERT(code != NULL);
+      function->ReplaceCode(code);
+      return true;
+    }
+  }
+
   // Generate the AST for the lazily compiled function.
   if (ParserApi::Parse(info, kNoParsingFlags)) {
     // 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());
 
     // After parsing we know the function's language mode. Remember it.
     LanguageMode language_mode = info->function()->language_mode();
     info->SetLanguageMode(language_mode);
@@ skipping 11 matching lines @@
       // 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()) {
         ASSERT(shared->scope_info() != ScopeInfo::Empty());
         function->ReplaceCode(*code);
+        if (FLAG_cache_optimized_code &&
+            code->kind() == Code::OPTIMIZED_FUNCTION) {
+          Handle<SharedFunctionInfo> shared(function->shared());
+          Handle<Context> global_context(function->context()->global_context());
+
+          // Create literals array that will be shared for this global context.
+          int number_of_literals = shared->num_literals();
+          Handle<FixedArray> literals =
+              isolate->factory()->NewFixedArray(number_of_literals);
+          if (number_of_literals > 0) {
+            // Store the object, regexp and array functions in the literals
+            // array prefix.  These functions will be used when creating
+            // object, regexp and array literals in this function.
+            literals->set(JSFunction::kLiteralGlobalContextIndex,
+                          function->context()->global_context());
+          }
+
+          SharedFunctionInfo::AddToOptimizedCodeMap(
+              shared, global_context, code, literals);
+        }
       } 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 setting the code object last we avoid this.
         Handle<ScopeInfo> scope_info = ScopeInfo::Create(info->scope());
         shared->set_scope_info(*scope_info);
         shared->set_code(*code);
         if (!function.is_null()) {
@@ skipping 159 matching lines @@
     }
   }
 
   GDBJIT(AddCode(Handle<String>(shared->DebugName()),
                  Handle<Script>(info->script()),
                  Handle<Code>(info->code()),
                  info));
 }
 
 } }  // namespace v8::internal