[inspector] implemented blackboxing inside v8

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 822 matching lines @@
   while (debug_info_list_ != NULL) {
     RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());
   }
 }
 
 void Debug::FloodWithOneShot(Handle<JSFunction> function,
                              BreakLocatorType type) {
   // Debug utility functions are not subject to debugging.
   if (function->native_context() == *debug_context()) return;
 
-  if (!function->shared()->IsSubjectToDebugging()) {
+  if (!function->shared()->IsSubjectToDebugging() ||
+      IsBlackboxed(function->shared())) {
     // Builtin functions are not subject to stepping, but need to be
     // deoptimized, because optimized code does not check for debug
     // step in at call sites.
     Deoptimizer::DeoptimizeFunction(*function);
     return;
   }
   // Make sure the function is compiled and has set up the debug info.
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if we failed to retrieve the debug info.
@@ skipping 98 matching lines @@
   if (last_step_action() == StepNext || last_step_action() == StepOut) {
     while (!it.done()) {
       Address current_fp = it.frame()->UnpaddedFP();
       if (current_fp >= thread_local_.target_fp_) break;
       it.Advance();
     }
   }
 
   // Find the closest Javascript frame we can flood with one-shots.
   while (!it.done() &&
-         !it.frame()->function()->shared()->IsSubjectToDebugging()) {
+         (!it.frame()->function()->shared()->IsSubjectToDebugging() ||
+          IsBlackboxed(it.frame()->function()->shared()))) {
     it.Advance();
   }
 
   if (it.done()) return;  // No suitable Javascript catch handler.
 
   FloodWithOneShot(Handle<JSFunction>(it.frame()->function()));
 }
 
 
 void Debug::PrepareStep(StepAction step_action) {
@@ skipping 39 matching lines @@
     return;
   }
 
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   BreakLocation location = BreakLocation::FromFrame(debug_info, frame);
 
   // Any step at a return is a step-out.
   if (location.IsReturn()) step_action = StepOut;
   // A step-next at a tail call is a step-out.
   if (location.IsTailCall() && step_action == StepNext) step_action = StepOut;
+  // A step-next in blackboxed function is a step-out.
+  if (step_action == StepNext && IsBlackboxed(shared)) step_action = StepOut;
 
   thread_local_.last_statement_position_ =
       summary.abstract_code()->SourceStatementPosition(summary.code_offset());
   thread_local_.last_fp_ = frame->UnpaddedFP();
   // No longer perform the current async step.
   clear_suspended_generator();
 
   switch (step_action) {
     case StepNone:
       UNREACHABLE();
       break;
     case StepOut:
       // Advance to caller frame.
       frames_it.Advance();
       // Skip native and extension functions on the stack.
-      while (!frames_it.done() &&
-             !frames_it.frame()->function()->shared()->IsSubjectToDebugging()) {
+      while (
+          !frames_it.done() &&
+          (!frames_it.frame()->function()->shared()->IsSubjectToDebugging() ||
+           IsBlackboxed(frames_it.frame()->function()->shared()))) {
         // Builtin functions are not subject to stepping, but need to be
         // deoptimized to include checks for step-in at call sites.
         Deoptimizer::DeoptimizeFunction(frames_it.frame()->function());
         frames_it.Advance();
       }
       if (!frames_it.done()) {
         // Fill the caller function to return to with one-shot break points.
         Handle<JSFunction> caller_function(frames_it.frame()->function());
         FloodWithOneShot(caller_function);
         thread_local_.target_fp_ = frames_it.frame()->UnpaddedFP();
@@ skipping 695 matching lines @@
   // Bail out if exception breaks are not active
   if (uncaught) {
     // Uncaught exceptions are reported by either flags.
     if (!(break_on_uncaught_exception_ || break_on_exception_)) return;
   } else {
     // Caught exceptions are reported is activated.
     if (!break_on_exception_) return;
   }
 
   {
-    // Check whether the break location is muted.
     JavaScriptFrameIterator it(isolate_);
-    if (!it.done() && IsMutedAtCurrentLocation(it.frame())) return;
+    // Check whether the top frame is blackboxed or the break location is muted.
+    if (!it.done() && (IsBlackboxed(it.frame()->function()->shared()) ||
+                       IsMutedAtCurrentLocation(it.frame()))) {
+      return;
+    }
   }
 
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
-  if (debug_event_listener_) {
+  if (debug_delegate_) {
     HandleScope scope(isolate_);
 
     // Create the execution state.
     Handle<Object> exec_state;
     // Bail out and don't call debugger if exception.
     if (!MakeExecutionState().ToHandle(&exec_state)) return;
 
-    debug_event_listener_->ExceptionThrown(
+    debug_delegate_->ExceptionThrown(
         GetDebugEventContext(isolate_),
         v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state)),
         v8::Utils::ToLocal(exception), promise->IsJSObject(), uncaught);
     if (!non_inspector_listener_exists()) return;
   }
 
   // Create the event data object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
   if (!MakeExceptionEvent(
           exception, uncaught, promise).ToHandle(&event_data)) {
     return;
   }
 
   // Process debug event.
   ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data));
   // Return to continue execution from where the exception was thrown.
 }
 
 void Debug::OnDebugBreak(Handle<Object> break_points_hit) {
   // The caller provided for DebugScope.
   AssertDebugContext();
   // Bail out if there is no listener for this event
   if (ignore_events()) return;
 
 #ifdef DEBUG
   PrintBreakLocation();
 #endif  // DEBUG
 
-  if (debug_event_listener_) {
+  if (debug_delegate_) {
     HandleScope scope(isolate_);
 
     // Create the execution state.
     Handle<Object> exec_state;
     // Bail out and don't call debugger if exception.
     if (!MakeExecutionState().ToHandle(&exec_state)) return;
 
     bool previous = in_debug_event_listener_;
     in_debug_event_listener_ = true;
-    debug_event_listener_->BreakProgramRequested(
+    debug_delegate_->BreakProgramRequested(
         GetDebugEventContext(isolate_),
         v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state)),
         v8::Utils::ToLocal(break_points_hit));
     in_debug_event_listener_ = previous;
     if (!non_inspector_listener_exists()) return;
   }
 
   HandleScope scope(isolate_);
   // Create the event data object.
   Handle<Object> event_data;
@@ skipping 63 matching lines @@
   // Since we holding promise when at least one microtask is scheduled (inside
   // PromiseReactionJobInfo), we can send cancel event in weak callback.
   GlobalHandles::MakeWeak(
       global_handle.location(),
       new CollectedCallbackData(global_handle.location(), async_id->value(),
                                 this, isolate_),
       &ResetPromiseHandle, v8::WeakCallbackType::kParameter);
   return async_id->value();
 }
 
+namespace {
+debug::Location GetDebugLocation(Handle<Script> script, int source_position) {
+  Script::PositionInfo info;
+  Script::GetPositionInfo(script, source_position, &info, Script::WITH_OFFSET);
+  return debug::Location(info.line, info.column);
+}
+}  // namespace
+
+bool Debug::IsBlackboxed(SharedFunctionInfo* shared) {
+  HandleScope scope(isolate_);
+  Handle<SharedFunctionInfo> shared_function_info(shared);
+  return IsBlackboxed(shared_function_info);
+}
+
+bool Debug::IsBlackboxed(Handle<SharedFunctionInfo> shared) {
+  if (!debug_delegate_) return false;
+  if (!shared->computed_debug_is_blackboxed()) {
+    bool is_blackboxed = false;
+    if (shared->script()->IsScript()) {
+      HandleScope handle_scope(isolate_);
+      Handle<Script> script(Script::cast(shared->script()));
+      if (script->type() == i::Script::TYPE_NORMAL) {
+        debug::Location start =
+            GetDebugLocation(script, shared->start_position());
+        debug::Location end = GetDebugLocation(script, shared->end_position());
+        is_blackboxed = debug_delegate_->IsFunctionBlackboxed(
+            ToApiHandle<debug::Script>(script), start, end);
+      }
+    }
+    shared->set_debug_is_blackboxed(is_blackboxed);
+    shared->set_computed_debug_is_blackboxed(true);
+  }
+  return shared->debug_is_blackboxed();
+}
+
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id) {
   if (in_debug_scope() || ignore_events()) return;
 
-  if (debug_event_listener_) {
-    debug_event_listener_->PromiseEventOccurred(type, id);
+  if (debug_delegate_) {
+    debug_delegate_->PromiseEventOccurred(type, id);
     if (!non_inspector_listener_exists()) return;
   }
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // Create the script collected state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
@@ skipping 51 matching lines @@
 void Debug::ProcessCompileEvent(v8::DebugEvent event, Handle<Script> script) {
   if (ignore_events()) return;
   if (script->type() != i::Script::TYPE_NORMAL &&
       script->type() != i::Script::TYPE_WASM) {
     return;
   }
   SuppressDebug while_processing(this);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
-  if (debug_event_listener_) {
-    debug_event_listener_->ScriptCompiled(ToApiHandle<debug::Script>(script),
-                                          event != v8::AfterCompile);
+  if (debug_delegate_) {
+    debug_delegate_->ScriptCompiled(ToApiHandle<debug::Script>(script),
+                                    event != v8::AfterCompile);
     if (!non_inspector_listener_exists()) return;
   }
 
   HandleScope scope(isolate_);
   // Create the compile state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
   if (!MakeCompileEvent(script, event).ToHandle(&event_data)) return;
 
   // Process debug event.
@@ skipping 23 matching lines @@
   // Set new entry.
   if (!callback->IsNullOrUndefined(isolate_)) {
     event_listener_ = global_handles->Create(*callback);
     if (data.is_null()) data = isolate_->factory()->undefined_value();
     event_listener_data_ = global_handles->Create(*data);
   }
 
   UpdateState();
 }
 
-
-void Debug::SetDebugEventListener(debug::DebugEventListener* listener) {
-  debug_event_listener_ = listener;
+void Debug::SetDebugDelegate(debug::DebugDelegate* delegate) {
+  debug_delegate_ = delegate;
   UpdateState();
 }
 
 void Debug::UpdateState() {
-  bool is_active =
-      !event_listener_.is_null() || debug_event_listener_ != nullptr;
+  bool is_active = !event_listener_.is_null() || debug_delegate_ != nullptr;
   if (is_active || in_debug_scope()) {
     // Note that the debug context could have already been loaded to
     // bootstrap test cases.
     isolate_->compilation_cache()->Disable();
     is_active = Load();
   } else if (is_loaded()) {
     isolate_->compilation_cache()->Enable();
     Unload();
   }
   is_active_ = is_active;
@@ skipping 36 matching lines @@
 
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) return;
 
   { JavaScriptFrameIterator it(isolate_);
     DCHECK(!it.done());
     Object* fun = it.frame()->function();
     if (fun && fun->IsJSFunction()) {
       // Don't stop in builtin functions.
       if (!JSFunction::cast(fun)->shared()->IsSubjectToDebugging()) return;
+      if (isolate_->stack_guard()->CheckDebugBreak() &&
+          IsBlackboxed(JSFunction::cast(fun)->shared())) {
+        Deoptimizer::DeoptimizeFunction(JSFunction::cast(fun));
+        return;
+      }
       JSGlobalObject* global =
           JSFunction::cast(fun)->context()->global_object();
       // Don't stop in debugger functions.
       if (IsDebugGlobal(global)) return;
       // Don't stop if the break location is muted.
       if (IsMutedAtCurrentLocation(it.frame())) return;
     }
   }
 
   isolate_->stack_guard()->ClearDebugBreak();
@@ skipping 177 matching lines @@
   return v8::Utils::ToLocal(callback_data_);
 }
 
 
 v8::Isolate* EventDetailsImpl::GetIsolate() const {
   return reinterpret_cast<v8::Isolate*>(exec_state_->GetIsolate());
 }
 
 }  // namespace internal
 }  // namespace v8