debug: cache SharedFunctionInfo for multi-bp set

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 731 matching lines @@
 
   debug_context_ = Handle<Context>::cast(
       isolate_->global_handles()->Create(*context));
   return true;
 }
 
 
 void Debug::Unload() {
   ClearAllBreakPoints();
   ClearStepping();
+  ClearSharedFunctionInfoInScript();
 
   // Return debugger is not loaded.
   if (!is_loaded()) return;
 
   // Clear the script cache.
   if (script_cache_ != NULL) {
     delete script_cache_;
     script_cache_ = NULL;
   }
 
@@ skipping 1231 matching lines @@
     RedirectActivationsToRecompiledCodeOnThread(isolate_,
                                                 isolate_->thread_local_top());
 
     ActiveFunctionsRedirector active_functions_redirector;
     isolate_->thread_manager()->IterateArchivedThreads(
           &active_functions_redirector);
   }
 }
 
 
+static int MatchSharedFunctionInfo(Handle<SharedFunctionInfo> shared,
+                                    int position,
+                                    Handle<SharedFunctionInfo> target,
+                                    int target_start_position) {
+  // If the SharedFunctionInfo found has the requested script data and
+  // contains the source position it is a candidate.
+  int start_position = shared->function_token_position();
+  if (start_position == RelocInfo::kNoPosition) {
+    start_position = shared->start_position();
+  }
+  if (start_position <= position &&
+      position <= shared->end_position()) {
+    // If there is no candidate or this function is within the current
+    // candidate this is the new candidate.
+    if (target.is_null()) {
+      return start_position;
+    } else {
+      if (target_start_position == start_position &&
+          shared->end_position() == target->end_position()) {
+        // If a top-level function contains only one function
+        // declaration the source for the top-level and the function
+        // is the same. In that case prefer the non top-level function.
+        if (!shared->is_toplevel()) {
+          return start_position;
+        }
+      } else if (target_start_position <= start_position &&
+                 shared->end_position() <= target->end_position()) {
+        // This containment check includes equality as a function
+        // inside a top-level function can share either start or end
+        // position with the top-level function.
+        return start_position;
+      }
+    }
+  }
+  return RelocInfo::kNoPosition;
+}
+
+
 Handle<Object> Debug::FindSharedFunctionInfoInScript(Handle<Script> script,
                                                      int position) {
   // Iterate the heap looking for SharedFunctionInfo generated from the
   // script. The inner most SharedFunctionInfo containing the source position
   // for the requested break point is found.
   // NOTE: This might require several heap iterations. If the SharedFunctionInfo
   // which is found is not compiled it is compiled and the heap is iterated
   // again as the compilation might create inner functions from the newly
   // compiled function and the actual requested break point might be in one of
   // these functions.
   // NOTE: The below fix-point iteration depends on all functions that cannot be
   // compiled lazily without a context to not be compiled at all. Compilation
   // will be triggered at points where we do not need a context.
   bool done = false;
   // The current candidate for the source position:
   int target_start_position = RelocInfo::kNoPosition;
   Handle<JSFunction> target_function;
   Handle<SharedFunctionInfo> target;
   Heap* heap = isolate_->heap();
+
+  if (!shared_info_list_.is_empty()) {
+    for (Handle<SharedFunctionInfo>* it = shared_info_list_.begin();
+         it != shared_info_list_.end();
+         it++) {
+      Handle<SharedFunctionInfo> shared = *it;
+      DCHECK(shared->script() == *script);
+
+      int start_position = MatchSharedFunctionInfo(shared,
+                                                   position,
+                                                   target,
+                                                   target_start_position);
+      if (start_position == RelocInfo::kNoPosition) continue;
+
+      target_start_position = start_position;
+      target = shared;
+    }
+
+    if (target.is_null()) return isolate_->factory()->undefined_value();
+    return target;
+  }
+
   while (!done) {
     { // Extra scope for iterator.
       // If lazy compilation is off, we won't have duplicate shared function
       // infos that need to be filtered.
       HeapIterator iterator(heap, FLAG_lazy ? HeapIterator::kNoFiltering
                                             : HeapIterator::kFilterUnreachable);
+
       for (HeapObject* obj = iterator.next();
            obj != NULL; obj = iterator.next()) {
         bool found_next_candidate = false;
         Handle<JSFunction> function;
         Handle<SharedFunctionInfo> shared;
         if (obj->IsJSFunction()) {
           function = Handle<JSFunction>(JSFunction::cast(obj));
           shared = Handle<SharedFunctionInfo>(function->shared());
           DCHECK(shared->allows_lazy_compilation() || shared->is_compiled());
           found_next_candidate = true;
         } else if (obj->IsSharedFunctionInfo()) {
           shared = Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(obj));
           // Skip functions that we cannot compile lazily without a context,
           // which is not available here, because there is no closure.
           found_next_candidate = shared->is_compiled() ||
               shared->allows_lazy_compilation_without_context();
         }
         if (!found_next_candidate) continue;
-        if (shared->script() == *script) {
-          // If the SharedFunctionInfo found has the requested script data and
-          // contains the source position it is a candidate.
-          int start_position = shared->function_token_position();
-          if (start_position == RelocInfo::kNoPosition) {
-            start_position = shared->start_position();
-          }
-          if (start_position <= position &&
-              position <= shared->end_position()) {
-            // If there is no candidate or this function is within the current
-            // candidate this is the new candidate.
-            if (target.is_null()) {
-              target_start_position = start_position;
-              target_function = function;
-              target = shared;
-            } else {
-              if (target_start_position == start_position &&
-                  shared->end_position() == target->end_position()) {
-                // If a top-level function contains only one function
-                // declaration the source for the top-level and the function
-                // is the same. In that case prefer the non top-level function.
-                if (!shared->is_toplevel()) {
-                  target_start_position = start_position;
-                  target_function = function;
-                  target = shared;
-                }
-              } else if (target_start_position <= start_position &&
-                         shared->end_position() <= target->end_position()) {
-                // This containment check includes equality as a function
-                // inside a top-level function can share either start or end
-                // position with the top-level function.
-                target_start_position = start_position;
-                target_function = function;
-                target = shared;
-              }
-            }
-          }
-        }
+        if (shared->script() != *script) continue;
+
+        int start_position = MatchSharedFunctionInfo(shared,
+                                                     position,
+                                                     target,
+                                                     target_start_position);
+        if (start_position == RelocInfo::kNoPosition) continue;
+
+        target_start_position = start_position;
+        target_function = function;
+        target = shared;
       }  // End for loop.
     }  // End no-allocation scope.
 
     if (target.is_null()) return isolate_->factory()->undefined_value();
 
     // There will be at least one break point when we are done.
     has_break_points_ = true;
 
     // If the candidate found is compiled we are done.
     done = target->is_compiled();
@@ skipping 22 matching lines @@
         shared->start_position_and_type() ==
             target->start_position_and_type()) {
       function->set_shared(*target);
     }
   }
 
   return target;
 }
 
 
+bool Debug::CollectSharedFunctionInfoInScript(Handle<Script> script) {
+  bool done = false;
+  // The current candidate for the source position:
+  Handle<JSFunction> target_function;
+  Handle<SharedFunctionInfo> target;
+  Heap* heap = isolate_->heap();
+  GlobalHandles* global_handles = isolate_->global_handles();
+  while (!done) {
+    DCHECK(shared_info_list_.is_empty());
+    done = true;
+
+    { // Extra scope for iterator.
+      // If lazy compilation is off, we won't have duplicate shared function
+      // infos that need to be filtered.
+      HeapIterator iterator(heap, FLAG_lazy ? HeapIterator::kNoFiltering
+                                            : HeapIterator::kFilterUnreachable);
+      for (HeapObject* obj = iterator.next();
+           obj != NULL; obj = iterator.next()) {
+        bool found_next_candidate = false;
+        Handle<JSFunction> function;
+        Handle<SharedFunctionInfo> shared;
+        if (obj->IsJSFunction()) {
+          function = Handle<JSFunction>(JSFunction::cast(obj));
+          shared = Handle<SharedFunctionInfo>(function->shared());
+          DCHECK(shared->allows_lazy_compilation() || shared->is_compiled());
+          found_next_candidate = true;
+        } else if (obj->IsSharedFunctionInfo()) {
+          shared = Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(obj));
+          // Skip functions that we cannot compile lazily without a context,
+          // which is not available here, because there is no closure.
+          found_next_candidate = shared->is_compiled() ||
+              shared->allows_lazy_compilation_without_context();
+        }
+        if (!found_next_candidate) continue;
+        if (shared->script() != *script) continue;
+
+        if (!shared->is_compiled()) {
+          target = shared;
+          target_function = function;
+          done = false;
+          break;
+        }
+
+        shared_info_list_.Add(global_handles->Create(*shared));
+      }  // End for loop.
+    }  // End no-allocation scope.
+
+    if (done) continue;
+
+    // Cleanup the list, next iteration will re-add all shared infos
+    ClearSharedFunctionInfoInScript();
+
+    // If the candidate is not compiled, compile it to reveal any inner
+    // functions which might contain the requested source position. This
+    // will compile all inner functions that cannot be compiled without a
+    // context, because Compiler::BuildFunctionInfo checks whether the
+    // debugger is active.
+    MaybeHandle<Code> maybe_result = target_function.is_null()
+        ? Compiler::GetUnoptimizedCode(target)
+        : Compiler::GetUnoptimizedCode(target_function);
+    if (maybe_result.is_null()) return false;
+  }  // End while loop.
+
+  return true;
+}
+
+
+void Debug::ClearSharedFunctionInfoInScript() {
+  while (!shared_info_list_.is_empty()) {
+    Handle<SharedFunctionInfo> shared = shared_info_list_.RemoveLast();
+    Object** location = reinterpret_cast<Object**>(shared.location());
+    GlobalHandles::Destroy(location);
+  }
+}
+
+
 // Ensures the debug information is present for shared.
 bool Debug::EnsureDebugInfo(Handle<SharedFunctionInfo> shared,
                             Handle<JSFunction> function) {
   Isolate* isolate = shared->GetIsolate();
 
   // Return if we already have the debug info for shared.
   if (HasDebugInfo(shared)) {
     DCHECK(shared->is_compiled());
     return true;
   }
@@ skipping 524 matching lines @@
     return;
   }
   DCHECK(update_script_break_points->IsJSFunction());
 
   // Wrap the script object in a proper JS object before passing it
   // to JavaScript.
   Handle<Object> wrapper = Script::GetWrapper(script);
 
   // Call UpdateScriptBreakPoints expect no exceptions.
   Handle<Object> argv[] = { wrapper };
+  ClearSharedFunctionInfoInScript();
   if (Execution::TryCall(Handle<JSFunction>::cast(update_script_break_points),
                          isolate_->js_builtins_object(),
                          arraysize(argv),
                          argv).is_null()) {
+    ClearSharedFunctionInfoInScript();
     return;
   }
 
   // Create the compile state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
   if (!MakeCompileEvent(script, v8::AfterCompile).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::AfterCompile, Handle<JSObject>::cast(event_data), true);
@@ skipping 718 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal