Pass PC offset into runtime when compiling for OSR.

src/optimizing-compiler-thread.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 216 matching lines @@
     osr_attempts_++;
   }
   input_queue_.Enqueue(optimizing_compiler);
   input_queue_semaphore_.Signal();
 }
 
 
 OptimizingCompiler* OptimizingCompilerThread::FindReadyOSRCandidate(
     Handle<JSFunction> function, uint32_t osr_pc_offset) {
   ASSERT(!IsOptimizerThread());
-  LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
-  for (int i = 0; i < ready_for_osr_.length(); i++) {
-    if (ready_for_osr_[i]->info()->HasSameOsrEntry(function, osr_pc_offset)) {
-      osr_hits_++;
-      return ready_for_osr_.Remove(i);
+  OptimizingCompiler* result = NULL;
+  { LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
+    for (int i = 0; i < ready_for_osr_.length(); i++) {
+      if (ready_for_osr_[i]->info()->HasSameOsrEntry(function, osr_pc_offset)) {
+        osr_hits_++;
+        result = ready_for_osr_.Remove(i);
+        break;
+      }
     }
   }
-  return NULL;
+  RemoveStaleOSRCandidates();
+  return result;
 }
 
 
 bool OptimizingCompilerThread::IsQueuedForOSR(Handle<JSFunction> function,
                                               uint32_t osr_pc_offset) {
   ASSERT(!IsOptimizerThread());
   LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
   for (int i = 0; i < osr_candidates_.length(); i++) {
     if (osr_candidates_[i]->info()->HasSameOsrEntry(function, osr_pc_offset)) {
       return true;
     }
   }
   return false;
 }
 
 
+bool OptimizingCompilerThread::IsQueuedForOSR(JSFunction* function) {
+  ASSERT(!IsOptimizerThread());
+  LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
+  for (int i = 0; i < osr_candidates_.length(); i++) {
+    if (*osr_candidates_[i]->info()->closure() == function) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
 void OptimizingCompilerThread::RemoveStaleOSRCandidates(int limit) {
   ASSERT(!IsOptimizerThread());
   LockGuard<Mutex> access_osr_lists(&osr_list_mutex_);
   while (ready_for_osr_.length() > limit) {
     OptimizingCompiler* compiler = ready_for_osr_.Remove(0);
     CompilationInfo* throw_away = compiler->info();
     if (FLAG_trace_osr) {
       PrintF("[COSR - Discarded ");
       throw_away->closure()->PrintName();
       PrintF(", AST id %d]\n",
              throw_away->osr_ast_id().ToInt());
     }
     delete throw_away;
   }
 }
 
 
 #ifdef DEBUG
 bool OptimizingCompilerThread::IsOptimizerThread() {
   if (!FLAG_concurrent_recompilation) return false;
   LockGuard<Mutex> lock_guard(&thread_id_mutex_);
   return ThreadId::Current().ToInteger() == thread_id_;
 }
 #endif
 
 
 } }  // namespace v8::internal