Pass PC offset into runtime when compiling 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 1100 matching lines @@
     InstallFullCode(*info);
   }
   // Optimized code is finally replacing unoptimized code.  Reset the latter's
   // profiler ticks to prevent too soon re-opt after a deopt.
   info->shared_info()->code()->set_profiler_ticks(0);
   ASSERT(!info->closure()->IsMarkedForInstallingRecompiledCode());
   return status == OptimizingCompiler::SUCCEEDED;
 }
 
 
-static uint32_t CurrentPcOffset(Isolate* isolate,
-                                Handle<JSFunction> function,
-                                Handle<Code> unoptimized) {
-  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
-  // the AST id matching the PC.
-  return static_cast<uint32_t>(frame->pc() - unoptimized->instruction_start());
-}
-
-
 static bool IsSuitableForOnStackReplacement(Isolate* isolate,
                                             Handle<JSFunction> function,
                                             Handle<Code> unoptimized) {
   // Keep track of whether we've succeeded in optimizing.
   if (!unoptimized->optimizable()) return false;
   // If we are trying to do OSR when there are already optimized
   // activations of the function, it means (a) the function is directly or
   // indirectly recursive and (b) an optimized invocation has been
   // deoptimized so that we are currently in an unoptimized activation.
   // Check for optimized activations of this function.
   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     if (frame->is_optimized() && frame->function() == *function) return false;
   }
 
   return true;
 }
 
 
 Handle<Code> Compiler::CompileForOnStackReplacement(
-      Handle<JSFunction> function) {
+    Handle<JSFunction> function, uint32_t pc_offset) {
   Isolate* isolate = function->GetIsolate();
   Handle<Code> unoptimized(function->shared()->code(), isolate);
 
   Deoptimizer::RevertInterruptCode(isolate, *unoptimized);

[titzer, 2013/09/10 11:00:46]

Please move this reversion of the interrupt code back into the runtime. The
compiler should not be responsible for doing so.

   if (FLAG_trace_osr) {
     PrintF("[OSR - restored original interrupt calls in ");
     function->PrintName();
     PrintF("]\n");
   }
 
   if (IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {

[titzer, 2013/09/10 11:00:46]

And this as well. The compiler should just compile code, not enforce policy
about when/where.

     // Find the PC offset in unoptimized code and translate to an AST id.
-    uint32_t pc_offset = CurrentPcOffset(isolate, function, unoptimized);
     BailoutId ast_id = unoptimized->TranslatePcOffsetToAstId(pc_offset);
     ASSERT(!ast_id.IsNone());
     if (FLAG_trace_osr) {
       PrintF("[OSR - replacing at AST id %d in ", ast_id.ToInt());
       function->PrintName();
       PrintF("]\n");
     }
 
     // Attempt OSR compilation.
     Handle<Code> result = JSFunction::CompileOsr(
@@ skipping 14 matching lines @@
 
   if (FLAG_trace_osr) {
     PrintF("[OSR - attempt failed for ");
     function->PrintName();
     PrintF("]\n");
   }
   return Handle<Code>::null();
 }
 
 
-Handle<Code> Compiler::CompileForConcurrentOSR(Handle<JSFunction> function) {
+Handle<Code> Compiler::CompileForConcurrentOSR(Handle<JSFunction> function,
+                                               uint32_t pc_offset) {
   Isolate* isolate = function->GetIsolate();
-  Handle<Code> unoptimized(function->shared()->code(), isolate);
-
-  uint32_t pc_offset = CurrentPcOffset(isolate, function, unoptimized);
 
   if (isolate->optimizing_compiler_thread()->
           IsQueuedForOSR(function, pc_offset)) {
     // Still waiting for the optimizing compiler thread to finish.  Carry on.
     if (FLAG_trace_osr) {
       PrintF("[COSR - polling recompile tasks for ");
       function->PrintName();
       PrintF("]\n");
     }
     return Handle<Code>::null();
   }
 
+  Handle<Code> unoptimized(function->shared()->code(), isolate);
   OptimizingCompiler* compiler = isolate->optimizing_compiler_thread()->
                                      FindReadyOSRCandidate(function, pc_offset);
 
   if (compiler != NULL) {
     if (FLAG_trace_osr) {
       PrintF("[COSR - optimization complete for ");
       function->PrintName();
       PrintF(", restoring interrupt calls]\n");
     }
     Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
@@ skipping 24 matching lines @@
         if (FLAG_trace_osr) {
           PrintF("[COSR - entry at AST id %d, offset %d in optimized code]\n",
                  ast_id.ToInt(), data->OsrPcOffset()->value());
         }
         return result;
       }
     }
     return Handle<Code>::null();
   }
 
-  if (!IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {
+  if (IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {
+    if (RecompileConcurrent(function, pc_offset)) return Handle<Code>::null();
+  } else {
     if (FLAG_trace_osr) {
       PrintF("[COSR - ");
       function->PrintName();
       PrintF(" is unsuitable, restoring interrupt calls]\n");
     }
-    Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
-    return Handle<Code>::null();
   }
 
-  if (!RecompileConcurrent(function, pc_offset)) {
-    Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
-  }
+  Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
   return Handle<Code>::null();
 }
 
 
 Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal,
                                                        Handle<Script> script) {
   // Precondition: code has been parsed and scopes have been analyzed.
   CompilationInfoWithZone info(script);
   info.SetFunction(literal);
   info.SetScope(literal->scope());
@@ skipping 153 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