[inspector] added Debugger.getPossibleBreakpoints method

src/debug/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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 1334 matching lines @@
   }
 
   // Update PCs on the stack to point to recompiled code.
   RedirectActiveFunctions redirect_visitor(*shared);
   redirect_visitor.VisitThread(isolate_, isolate_->thread_local_top());
   isolate_->thread_manager()->IterateArchivedThreads(&redirect_visitor);
 
   return true;
 }
 
+bool Debug::FindBreakablePositions(Handle<DebugInfo> debug_info,
+                                   int start_position, int end_position,
+                                   BreakPositionAlignment alignment,
+                                   std::vector<int>& offsets) {
+  int statement_position;
+  int position;
+  if (debug_info->HasDebugCode()) {
+    CodeBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);
+    it.SkipToPosition(start_position, alignment);
+    while (!it.Done() && it.position() < end_position &&
+           it.position() >= start_position) {
+      statement_position = it.statement_position();
+      position = it.position();
+      offsets.push_back(alignment == STATEMENT_ALIGNED ? statement_position
+                                                       : position);
+      it.Next();
+    }
+  } else {
+    DCHECK(debug_info->HasDebugBytecodeArray());
+    BytecodeArrayBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

[Yang, 2016/11/02 13:51:15]

This is just duplicate code. Can we either use virtual methods or templates to
avoid that?

[kozy, 2016/11/03 01:15:02]

Done.

+    it.SkipToPosition(start_position, alignment);
+    while (!it.Done() && it.position() < end_position &&
+           it.position() >= start_position) {
+      statement_position = it.statement_position();
+      position = it.position();
+      offsets.push_back(alignment == STATEMENT_ALIGNED ? statement_position
+                                                       : position);
+      it.Next();
+    }
+  }
+  return true;
+}
+
+bool Debug::GetPossibleBreakpoints(Handle<Script> script, int start_position,
+                                   int end_position,
+                                   std::vector<int>& offsets) {
+  for (int iteration = 0;; iteration++) {
+    std::vector<int> current;
+    if (!script->shared_function_infos()->IsWeakFixedArray()) break;
+    WeakFixedArray::Iterator iterator(script->shared_function_infos());
+    SharedFunctionInfo* candidate;
+    bool should_restart = false;
+    while ((candidate = iterator.Next<SharedFunctionInfo>())) {
+      if (!candidate) break;

[Yang, 2016/11/02 13:51:15]

this seems redundant.

[kozy, 2016/11/03 01:15:02]

Removed.

+      if (candidate->end_position() < start_position ||
+          candidate->start_position() >= end_position)
+        continue;
+      if (candidate->HasDebugCode()) {
+        Handle<SharedFunctionInfo> shared_handle(candidate);
+        if (!shared_handle->IsSubjectToDebugging()) continue;
+        if (!shared_handle->HasDebugInfo()) {
+          AllowHeapAllocation allow_before_return;

[Yang, 2016/11/02 13:51:15]

This is not safe. Once GC happens, the weak fixed array iterator can get into an
inconsistent state. If we simply exit the loop after this, it's fine. But we
actually may continue here.

Can we simply do something like this:

1. collect all shared function infos in the source range
2. ensure that these shared function infos are all compiled, if not, compile,
and repeat from 1.
3. collect break point locations from shared function infos collected in 1.

[kozy, 2016/11/03 01:15:02]

Thank you!
Done.

+          CreateDebugInfo(shared_handle);
+        }
+        Handle<DebugInfo> debug_info(shared_handle->GetDebugInfo());
+        if (!FindBreakablePositions(debug_info, start_position, end_position,
+                                    STATEMENT_ALIGNED, current))
+          return false;
+        continue;
+      }
+      if (candidate->allows_lazy_compilation()) {
+        HandleScope scope(isolate_);
+        AllowHeapAllocation allow_before_return;
+        if (!Compiler::CompileDebugCode(handle(candidate))) {
+          return false;
+        } else {
+          should_restart = true;
+        }
+        break;
+      }
+    }
+    if (should_restart) continue;
+    offsets.swap(current);
+    return true;
+  }
+  return true;
+}
+
 void Debug::RecordAsyncFunction(Handle<JSGeneratorObject> generator_object) {
   if (last_step_action() <= StepOut) return;
   if (!IsAsyncFunction(generator_object->function()->shared()->kind())) return;
   DCHECK(!has_suspended_generator());
   thread_local_.suspended_generator_ = *generator_object;
   ClearStepping();
 }
 
 class SharedFunctionInfoFinder {
  public:
@@ skipping 1196 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8