Generate a custom OSR entrypoint for OSR compiles on all platforms, and transition to optimized cod…

src/runtime.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 8170 matching lines @@
 RUNTIME_FUNCTION(MaybeObject*, Runtime_LazyRecompile) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   Handle<JSFunction> function = args.at<JSFunction>(0);
 
   if (!AllowOptimization(isolate, function)) {
     function->ReplaceCode(function->shared()->code());
     return function->code();
   }
   function->shared()->code()->set_profiler_ticks(0);
-  if (JSFunction::CompileOptimized(function,
-                                   BailoutId::None(),
-                                   CLEAR_EXCEPTION)) {
+  if (JSFunction::CompileOptimized(function, CLEAR_EXCEPTION)) {
     return function->code();
   }
   if (FLAG_trace_opt) {
     PrintF("[failed to optimize ");
     function->PrintName();
     PrintF(": optimized compilation failed]\n");
   }
   function->ReplaceCode(function->shared()->code());
   return function->code();
 }
@@ skipping 72 matching lines @@
 
   // Make sure to materialize objects before causing any allocation.
   JavaScriptFrameIterator it(isolate);
   deoptimizer->MaterializeHeapObjects(&it);
   delete deoptimizer;
 
   JavaScriptFrame* frame = it.frame();
   RUNTIME_ASSERT(frame->function()->IsJSFunction());
   Handle<JSFunction> function(frame->function(), isolate);
   Handle<Code> optimized_code(function->code());
-  RUNTIME_ASSERT((type != Deoptimizer::EAGER &&
-                  type != Deoptimizer::SOFT) || function->IsOptimized());
 
   // Avoid doing too much work when running with --always-opt and keep
   // the optimized code around.
   if (FLAG_always_opt || type == Deoptimizer::LAZY) {
     return isolate->heap()->undefined_value();
   }
 
   // Find other optimized activations of the function or functions that
   // share the same optimized code.
   bool has_other_activations = false;

[Michael Starzinger, 2013/07/31 14:55:50]

We should only look for activations of optimized code on the stack. If
function->code() is unoptimized then lookup for other activations of
function->code() is not correct.

We need some way to get the _optimized_ code from which we deoptimized, even if
it's not installed in the function. AFAICT, the Deoptimizer::compiled_code field
should be accurate at the very top of this method. The below loop should look
for activations of that code object instead.

[Michael Starzinger, 2013/07/31 16:29:33]

As discussed offline: Yes, your are right, if function->code() is not optimized,
then there should be no further activations on the stack because the same OSR
code cannot be reused. So we should just do an early return before looking for
activations if "!function->IsOptimized()". Agreed.

   while (!it.done()) {
     JavaScriptFrame* frame = it.frame();
     JSFunction* other_function = frame->function();
     if (frame->is_optimized() && other_function->code() == function->code()) {
       has_other_activations = true;
       break;
     }
     it.Advance();
   }
 
@@ skipping 173 matching lines @@
     // Check for optimized activations of this function.
     JavaScriptFrameIterator it(isolate);
     while (succeeded && !it.done()) {
       JavaScriptFrame* frame = it.frame();
       succeeded = !frame->is_optimized() || frame->function() != *function;
       it.Advance();
     }
   }
 
   BailoutId ast_id = BailoutId::None();
+  Handle<Code> osr_code = Handle<Code>::null();
   if (succeeded) {
     // The top JS function is this one, the PC is somewhere in the
     // unoptimized code.
     JavaScriptFrameIterator it(isolate);
     JavaScriptFrame* frame = it.frame();
     ASSERT(frame->function() == *function);
     ASSERT(frame->LookupCode() == *unoptimized);
     ASSERT(unoptimized->contains(frame->pc()));
 
     // Use linear search of the unoptimized code's back edge table to find
@@ skipping 15 matching lines @@
       table_cursor += FullCodeGenerator::kBackEdgeEntrySize;
     }
     ASSERT(!ast_id.IsNone());
     if (FLAG_trace_osr) {
       PrintF("[replacing on-stack at AST id %d, loop depth %d in ",
               ast_id.ToInt(), loop_depth);
       function->PrintName();
       PrintF("]\n");
     }
 
-    // Try to compile the optimized code.  A true return value from
-    // CompileOptimized means that compilation succeeded, not necessarily
-    // that optimization succeeded.
-    if (JSFunction::CompileOptimized(function, ast_id, CLEAR_EXCEPTION) &&
-        function->IsOptimized()) {
+    // Try to compile the function for OSR. A non-null return value indicates
+    // the compilation succeeded for the given AST id.
+    osr_code = JSFunction::CompileOsr(function, ast_id, CLEAR_EXCEPTION);
+
+    if (!osr_code.is_null() &&
+        osr_code->kind() == Code::OPTIMIZED_FUNCTION) {
       DeoptimizationInputData* data = DeoptimizationInputData::cast(
-          function->code()->deoptimization_data());
-      if (data->OsrPcOffset()->value() >= 0) {
+          osr_code->deoptimization_data());
+      if (data->OsrPcOffset()->value() >= 0
+          && BailoutId(data->OsrAstId()->value()) == ast_id) {
         if (FLAG_trace_osr) {
           PrintF("[on-stack replacement offset %d in optimized code]\n",
                data->OsrPcOffset()->value());
         }
-        ASSERT(BailoutId(data->OsrAstId()->value()) == ast_id);
       } else {
-        // We may never generate the desired OSR entry if we emit an
-        // early deoptimize.
-        succeeded = false;
+        // The code we got back did not match our OSR compile request.
+        osr_code = Handle<Code>::null();
       }
     } else {
-      succeeded = false;
+      osr_code = Handle<Code>::null();
     }
   }
 
   // Revert to the original interrupt calls in the original unoptimized code.
   if (FLAG_trace_osr) {
     PrintF("[restoring original interrupt calls in ");
     function->PrintName();
     PrintF("]\n");
   }
   InterruptStub interrupt_stub;
   Handle<Code> interrupt_code = interrupt_stub.GetCode(isolate);
   Handle<Code> replacement_code = isolate->builtins()->OnStackReplacement();
   Deoptimizer::RevertInterruptCode(*unoptimized,
                                    *interrupt_code,
                                    *replacement_code);
 
-  // If the optimization attempt succeeded, return the AST id tagged as a
-  // smi. This tells the builtin that we need to translate the unoptimized
-  // frame to an optimized one.
-  if (succeeded) {
-    ASSERT(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
-    return Smi::FromInt(ast_id.ToInt());
-  } else {
-    if (function->IsMarkedForLazyRecompilation()) {
-      function->ReplaceCode(function->shared()->code());
-    }
-    return Smi::FromInt(-1);
-  }
+  // Return the code object to the calling builtin. If non-null, the builtin
+  // will jump directly to its OSR entrypoint.
+  return osr_code.is_null() ? NULL: *osr_code;

[Michael Starzinger, 2013/07/31 14:55:50]

nit: Missing white-space in front of the colon.

 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_CheckIsBootstrapping) {
   SealHandleScope shs(isolate);
   RUNTIME_ASSERT(isolate->bootstrapper()->IsActive());
   return isolate->heap()->undefined_value();
 }
 
 
@@ skipping 5323 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal