v8::internal::Debug Class Reference

#include <debug.h>

Collaboration diagram for v8::internal::Debug:

Classes
class	ThreadLocal

Public Member Functions
void	OnDebugBreak (Handle< Object > break_points_hit, bool auto_continue)
void	OnThrow (Handle< Object > exception, bool uncaught)
void	OnPromiseReject (Handle< JSObject > promise, Handle< Object > value)
void	OnCompileError (Handle< Script > script)
void	OnBeforeCompile (Handle< Script > script)
void	OnAfterCompile (Handle< Script > script)
void	OnPromiseEvent (Handle< JSObject > data)
void	OnAsyncTaskEvent (Handle< JSObject > data)
void	SetEventListener (Handle< Object > callback, Handle< Object > data)
void	SetMessageHandler (v8::Debug::MessageHandler handler)
void	EnqueueCommandMessage (Vector< const uint16_t > command, v8::Debug::ClientData *client_data=NULL)
void	EnqueueDebugCommand (v8::Debug::ClientData *client_data=NULL)
MUST_USE_RESULT MaybeHandle< Object >	Call (Handle< JSFunction > fun, Handle< Object > data)
Handle< Context >	GetDebugContext ()
void	HandleDebugBreak ()
void	ProcessDebugMessages (bool debug_command_only)
bool	Load ()
void	Break (Arguments args, JavaScriptFrame *)
void	SetAfterBreakTarget (JavaScriptFrame *frame)
Handle< FixedArray >	GetLoadedScripts ()
bool	SetBreakPoint (Handle< JSFunction > function, Handle< Object > break_point_object, int *source_position)
bool	SetBreakPointForScript (Handle< Script > script, Handle< Object > break_point_object, int *source_position, BreakPositionAlignment alignment)
void	ClearBreakPoint (Handle< Object > break_point_object)
void	ClearAllBreakPoints ()
void	FloodWithOneShot (Handle< JSFunction > function)
void	FloodBoundFunctionWithOneShot (Handle< JSFunction > function)
void	FloodHandlerWithOneShot ()
void	ChangeBreakOnException (ExceptionBreakType type, bool enable)
bool	IsBreakOnException (ExceptionBreakType type)
void	PrepareStep (StepAction step_action, int step_count, StackFrame::Id frame_id)
void	ClearStepping ()
void	ClearStepOut ()
bool	IsStepping ()
bool	StepNextContinue (BreakLocationIterator *break_location_iterator, JavaScriptFrame *frame)
bool	StepInActive ()
void	HandleStepIn (Handle< JSFunction > function, Handle< Object > holder, Address fp, bool is_constructor)
bool	StepOutActive ()
void	PrepareForBreakPoints ()
bool	EnsureDebugInfo (Handle< SharedFunctionInfo > shared, Handle< JSFunction > function)
Object *	FindSharedFunctionInfoInScript (Handle< Script > script, int position)
bool	IsDebugGlobal (GlobalObject *global)
bool	IsBreakAtReturn (JavaScriptFrame *frame)
void	FramesHaveBeenDropped (StackFrame::Id new_break_frame_id, LiveEdit::FrameDropMode mode, Object **restarter_frame_function_pointer)
char *	ArchiveDebug (char *to)
char *	RestoreDebug (char *from)
void	FreeThreadResources ()
DebugScope *	debugger_entry ()
Handle< Context >	debug_context ()
void	set_live_edit_enabled (bool v)
bool	live_edit_enabled () const
bool	is_active () const
bool	is_loaded () const
bool	has_break_points () const
bool	in_debug_scope () const
void	set_disable_break (bool v)
StackFrame::Id	break_frame_id ()
int	break_id ()
Address	is_active_address ()
Address	after_break_target_address ()
Address	restarter_frame_function_pointer_address ()
Address	step_in_fp_addr ()

Static Public Member Functions
static Handle< DebugInfo >	GetDebugInfo (Handle< SharedFunctionInfo > shared)
static bool	HasDebugInfo (Handle< SharedFunctionInfo > shared)
static bool	IsDebugBreak (Address addr)
static bool	IsDebugBreakAtReturn (RelocInfo *rinfo)
static Handle< Object >	GetSourceBreakLocations (Handle< SharedFunctionInfo > shared, BreakPositionAlignment position_aligment)
static void	HandleWeakDebugInfo (const v8::WeakCallbackData< v8::Value, void > &data)
static int	ArchiveSpacePerThread ()
static void	RecordEvalCaller (Handle< Script > script)

Private Member Functions
	Debug (Isolate *isolate)
void	UpdateState ()
void	Unload ()
void	SetNextBreakId ()
bool	has_commands () const
bool	ignore_events () const
void	OnException (Handle< Object > exception, bool uncaught, Handle< Object > promise)
MUST_USE_RESULT MaybeHandle< Object >	MakeJSObject (const char *constructor_name, int argc, Handle< Object > argv[])
MUST_USE_RESULT MaybeHandle< Object >	MakeExecutionState ()
MUST_USE_RESULT MaybeHandle< Object >	MakeBreakEvent (Handle< Object > break_points_hit)
MUST_USE_RESULT MaybeHandle< Object >	MakeExceptionEvent (Handle< Object > exception, bool uncaught, Handle< Object > promise)
MUST_USE_RESULT MaybeHandle< Object >	MakeCompileEvent (Handle< Script > script, v8::DebugEvent type)
MUST_USE_RESULT MaybeHandle< Object >	MakePromiseEvent (Handle< JSObject > promise_event)
MUST_USE_RESULT MaybeHandle< Object >	MakeAsyncTaskEvent (Handle< JSObject > task_event)
void	ClearMirrorCache ()
bool	PromiseHasRejectHandler (Handle< JSObject > promise)
void	CallEventCallback (v8::DebugEvent event, Handle< Object > exec_state, Handle< Object > event_data, v8::Debug::ClientData *client_data)
void	ProcessDebugEvent (v8::DebugEvent event, Handle< JSObject > event_data, bool auto_continue)
void	NotifyMessageHandler (v8::DebugEvent event, Handle< JSObject > exec_state, Handle< JSObject > event_data, bool auto_continue)
void	InvokeMessageHandler (MessageImpl message)
void	ClearOneShot ()
void	ActivateStepIn (StackFrame *frame)
void	ClearStepIn ()
void	ActivateStepOut (StackFrame *frame)
void	ClearStepNext ()
void	RemoveDebugInfo (Handle< DebugInfo > debug_info)
Handle< Object >	CheckBreakPoints (Handle< Object > break_point)
bool	CheckBreakPoint (Handle< Object > break_point_object)
void	AssertDebugContext ()
void	ThreadInit ()
	DISALLOW_COPY_AND_ASSIGN (Debug)

Static Private Member Functions
static bool	CompileDebuggerScript (Isolate *isolate, int index)

Private Attributes
Handle< Context >	debug_context_
Handle< Object >	event_listener_
Handle< Object >	event_listener_data_
v8::Debug::MessageHandler	message_handler_
base::Semaphore	command_received_
LockingCommandMessageQueue	command_queue_
LockingCommandMessageQueue	event_command_queue_
bool	is_active_
bool	is_suppressed_
bool	live_edit_enabled_
bool	has_break_points_
bool	break_disabled_
bool	break_on_exception_
bool	break_on_uncaught_exception_
ScriptCache *	script_cache_
DebugInfoListNode *	debug_info_list_
Address	after_break_target_
ThreadLocal	thread_local_
Isolate *	isolate_

Static Private Attributes
static const int	kQueueInitialSize = 4

Friends
class	Isolate
class	DebugScope
class	DisableBreak
class	LiveEdit
class	SuppressDebug
Handle< FixedArray >	GetDebuggedFunctions ()
void	CheckDebuggerUnloaded (bool check_functions)

Detailed Description

Definition at line 343 of file debug.h.

Constructor & Destructor Documentation

Debug()

v8::internal::Debug::Debug ( Isolate *  isolate )

explicitprivate

Definition at line 30 of file debug.cc.

    : debug_context_(Handle<Context>()),
      event_listener_(Handle<Object>()),
      event_listener_data_(Handle<Object>()),
      message_handler_(NULL),
      command_received_(0),
      command_queue_(isolate->logger(), kQueueInitialSize),
      event_command_queue_(isolate->logger(), kQueueInitialSize),
      is_active_(false),
      is_suppressed_(false),
      live_edit_enabled_(true),  // TODO(yangguo): set to false by default.
      has_break_points_(false),
      break_disabled_(false),
      break_on_exception_(false),
      break_on_uncaught_exception_(false),
      script_cache_(NULL),
      debug_info_list_(NULL),
      isolate_(isolate) {
  ThreadInit();
}

References ThreadInit().

Here is the call graph for this function:

Member Function Documentation

ActivateStepIn()

void v8::internal::Debug::ActivateStepIn ( StackFrame *  frame )

private

Definition at line 1675 of file debug.cc.

                                            {
  DCHECK(!StepOutActive());
  thread_local_.step_into_fp_ = frame->UnpaddedFP();
}

References DCHECK, v8::internal::Debug::ThreadLocal::step_into_fp_, StepOutActive(), and thread_local_.

Referenced by PrepareStep().

Here is the call graph for this function:

Here is the caller graph for this function:

ActivateStepOut()

void v8::internal::Debug::ActivateStepOut ( StackFrame *  frame )

private

Definition at line 1686 of file debug.cc.

                                             {
  DCHECK(!StepInActive());
  thread_local_.step_out_fp_ = frame->UnpaddedFP();
}

References DCHECK, v8::internal::Debug::ThreadLocal::step_out_fp_, StepInActive(), and thread_local_.

Referenced by PrepareStep().

Here is the call graph for this function:

Here is the caller graph for this function:

after_break_target_address()

Address v8::internal::Debug::after_break_target_address ( )

inline

Definition at line 481 of file debug.h.

                                       {
    return reinterpret_cast<Address>(&after_break_target_);
  }

References after_break_target_.

ArchiveDebug()

char * v8::internal::Debug::ArchiveDebug

(

char *

to

)

Definition at line 571 of file debug.cc.

                                       {
  char* to = storage;
  MemCopy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));
  ThreadInit();
  return storage + ArchiveSpacePerThread();
}

References ArchiveSpacePerThread(), v8::internal::MemCopy(), thread_local_, ThreadInit(), and to().

Referenced by v8::internal::ThreadManager::EagerlyArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

ArchiveSpacePerThread()

int v8::internal::Debug::ArchiveSpacePerThread ( )

static

Definition at line 586 of file debug.cc.

                                 {
  return sizeof(ThreadLocal);
}

Referenced by ArchiveDebug(), v8::internal::ArchiveSpacePerThread(), and RestoreDebug().

Here is the caller graph for this function:

AssertDebugContext()

void v8::internal::Debug::AssertDebugContext ( )

inlineprivate

Definition at line 559 of file debug.h.

                                   {
    DCHECK(isolate_->context() == *debug_context());
    DCHECK(in_debug_scope());
  }

References v8::internal::Isolate::context(), DCHECK, debug_context(), in_debug_scope(), and isolate_.

Referenced by ClearMirrorCache(), MakeJSObject(), and OnDebugBreak().

Here is the call graph for this function:

Here is the caller graph for this function:

Break()

void v8::internal::Debug::Break	(	Arguments	args,
		JavaScriptFrame *	frame
	)

Definition at line 866 of file debug.cc.

                                                        {
  Heap* heap = isolate_->heap();
  HandleScope scope(isolate_);
  DCHECK(args.length() == 0);
 
  // Initialize LiveEdit.
  LiveEdit::InitializeThreadLocal(this);
 
  // Just continue if breaks are disabled or debugger cannot be loaded.
  if (break_disabled_) return;
 
  // Enter the debugger.
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // Postpone interrupt during breakpoint processing.
  PostponeInterruptsScope postpone(isolate_);
 
  // Get the debug info (create it if it does not exist).
  Handle<SharedFunctionInfo> shared =
      Handle<SharedFunctionInfo>(frame->function()->shared());
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
 
  // Find the break point where execution has stopped.
  BreakLocationIterator break_location_iterator(debug_info,
                                                ALL_BREAK_LOCATIONS);
  // pc points to the instruction after the current one, possibly a break
  // location as well. So the "- 1" to exclude it from the search.
  break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
 
  // Check whether step next reached a new statement.
  if (!StepNextContinue(&break_location_iterator, frame)) {
    // Decrease steps left if performing multiple steps.
    if (thread_local_.step_count_ > 0) {
      thread_local_.step_count_--;
    }
  }
 
  // If there is one or more real break points check whether any of these are
  // triggered.
  Handle<Object> break_points_hit(heap->undefined_value(), isolate_);
  if (break_location_iterator.HasBreakPoint()) {
    Handle<Object> break_point_objects =
        Handle<Object>(break_location_iterator.BreakPointObjects(), isolate_);
    break_points_hit = CheckBreakPoints(break_point_objects);
  }
 
  // If step out is active skip everything until the frame where we need to step
  // out to is reached, unless real breakpoint is hit.
  if (StepOutActive() &&
      frame->fp() != thread_local_.step_out_fp_ &&
      break_points_hit->IsUndefined() ) {
      // Step count should always be 0 for StepOut.
      DCHECK(thread_local_.step_count_ == 0);
  } else if (!break_points_hit->IsUndefined() ||
             (thread_local_.last_step_action_ != StepNone &&
              thread_local_.step_count_ == 0)) {
    // Notify debugger if a real break point is triggered or if performing
    // single stepping with no more steps to perform. Otherwise do another step.
 
    // Clear all current stepping setup.
    ClearStepping();
 
    if (thread_local_.queued_step_count_ > 0) {
      // Perform queued steps
      int step_count = thread_local_.queued_step_count_;
 
      // Clear queue
      thread_local_.queued_step_count_ = 0;
 
      PrepareStep(StepNext, step_count, StackFrame::NO_ID);
    } else {
      // Notify the debug event listeners.
      OnDebugBreak(break_points_hit, false);
    }
  } else if (thread_local_.last_step_action_ != StepNone) {
    // Hold on to last step action as it is cleared by the call to
    // ClearStepping.
    StepAction step_action = thread_local_.last_step_action_;
    int step_count = thread_local_.step_count_;
 
    // If StepNext goes deeper in code, StepOut until original frame
    // and keep step count queued up in the meantime.
    if (step_action == StepNext && frame->fp() < thread_local_.last_fp_) {
      // Count frames until target frame
      int count = 0;
      JavaScriptFrameIterator it(isolate_);
      while (!it.done() && it.frame()->fp() < thread_local_.last_fp_) {
        count++;
        it.Advance();
      }
 
      // Check that we indeed found the frame we are looking for.
      CHECK(!it.done() && (it.frame()->fp() == thread_local_.last_fp_));
      if (step_count > 1) {
        // Save old count and action to continue stepping after StepOut.
        thread_local_.queued_step_count_ = step_count - 1;
      }
 
      // Set up for StepOut to reach target frame.
      step_action = StepOut;
      step_count = count;
    }
 
    // Clear all current stepping setup.
    ClearStepping();
 
    // Set up for the remaining steps.
    PrepareStep(step_action, step_count, StackFrame::NO_ID);
  }
}

References v8::internal::ALL_BREAK_LOCATIONS, break_disabled_, v8::internal::BreakLocationIterator::BreakPointObjects(), CHECK, CheckBreakPoints(), ClearStepping(), DCHECK, DebugScope, v8::internal::BreakLocationIterator::FindBreakLocationFromAddress(), v8::internal::JavaScriptFrame::function(), GetDebugInfo(), v8::internal::BreakLocationIterator::HasBreakPoint(), v8::internal::Isolate::heap(), v8::internal::LiveEdit::InitializeThreadLocal(), isolate_, v8::internal::Debug::ThreadLocal::last_fp_, v8::internal::Debug::ThreadLocal::last_step_action_, OnDebugBreak(), PrepareStep(), v8::internal::Debug::ThreadLocal::queued_step_count_, v8::internal::Debug::ThreadLocal::step_count_, v8::internal::Debug::ThreadLocal::step_out_fp_, v8::internal::StepNext, StepNextContinue(), v8::internal::StepNone, v8::internal::StepOut, StepOutActive(), and thread_local_.

Here is the call graph for this function:

break_frame_id()

StackFrame::Id v8::internal::Debug::break_frame_id ( )

inline

Definition at line 473 of file debug.h.

{ return thread_local_.break_frame_id_; }

References v8::internal::Debug::ThreadLocal::break_frame_id_, and thread_local_.

Referenced by v8::internal::DropActivationsInActiveThreadImpl(), FloodHandlerWithOneShot(), and PrepareStep().

Here is the caller graph for this function:

break_id()

int v8::internal::Debug::break_id ( )

inline

Definition at line 474 of file debug.h.

{ return thread_local_.break_id_; }

References v8::internal::Debug::ThreadLocal::break_id_, and thread_local_.

Referenced by CheckBreakPoint(), v8::internal::CheckExecutionState(), MakeBreakEvent(), MakeExceptionEvent(), and MakeExecutionState().

Here is the caller graph for this function:

Call()

MaybeHandle< Object > v8::internal::Debug::Call	(	Handle< JSFunction >	fun,
		Handle< Object >	data
	)

Definition at line 3004 of file debug.cc.

                                                                           {
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return isolate_->factory()->undefined_value();
 
  // Create the execution state.
  Handle<Object> exec_state;
  if (!MakeExecutionState().ToHandle(&exec_state)) {
    return isolate_->factory()->undefined_value();
  }
 
  Handle<Object> argv[] = { exec_state, data };
  return Execution::Call(
      isolate_,
      fun,
      Handle<Object>(debug_context()->global_proxy(), isolate_),
      arraysize(argv),
      argv);
}

References arraysize, debug_context(), DebugScope, v8::internal::Isolate::factory(), isolate_, and MakeExecutionState().

Referenced by v8::Debug::Call().

Here is the call graph for this function:

Here is the caller graph for this function:

CallEventCallback()

void v8::internal::Debug::CallEventCallback ( v8::DebugEvent  event, Handle< Object >  exec_state, Handle< Object >  event_data, v8::Debug::ClientData *  client_data  )

private

Definition at line 2748 of file debug.cc.

                                                              {
  if (event_listener_->IsForeign()) {
    // Invoke the C debug event listener.
    v8::Debug::EventCallback callback =
        FUNCTION_CAST<v8::Debug::EventCallback>(
            Handle<Foreign>::cast(event_listener_)->foreign_address());
    EventDetailsImpl event_details(event,
                                   Handle<JSObject>::cast(exec_state),
                                   Handle<JSObject>::cast(event_data),
                                   event_listener_data_,
                                   client_data);
    callback(event_details);
    DCHECK(!isolate_->has_scheduled_exception());
  } else {
    // Invoke the JavaScript debug event listener.
    DCHECK(event_listener_->IsJSFunction());
    Handle<Object> argv[] = { Handle<Object>(Smi::FromInt(event), isolate_),
                              exec_state,
                              event_data,
                              event_listener_data_ };
    Handle<JSReceiver> global(isolate_->global_proxy());
    Execution::TryCall(Handle<JSFunction>::cast(event_listener_),
                       global, arraysize(argv), argv);
  }
}

References arraysize, DCHECK, event_listener_, event_listener_data_, v8::internal::Smi::FromInt(), v8::internal::Isolate::global_proxy(), v8::internal::Isolate::has_scheduled_exception(), and isolate_.

Referenced by ProcessDebugEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

ChangeBreakOnException()

void v8::internal::Debug::ChangeBreakOnException	(	ExceptionBreakType	type,
		bool	enable
	)

Definition at line 1247 of file debug.cc.

                                                                       {
  if (type == BreakUncaughtException) {
    break_on_uncaught_exception_ = enable;
  } else {
    break_on_exception_ = enable;
  }
}

References break_on_exception_, break_on_uncaught_exception_, and v8::internal::BreakUncaughtException.

CheckBreakPoint()

bool v8::internal::Debug::CheckBreakPoint ( Handle< Object >  break_point_object )

private

Definition at line 1027 of file debug.cc.

                                                             {
  Factory* factory = isolate_->factory();
  HandleScope scope(isolate_);
 
  // Ignore check if break point object is not a JSObject.
  if (!break_point_object->IsJSObject()) return true;
 
  // Get the function IsBreakPointTriggered (defined in debug-debugger.js).
  Handle<String> is_break_point_triggered_string =
      factory->InternalizeOneByteString(
          STATIC_CHAR_VECTOR("IsBreakPointTriggered"));
  Handle<GlobalObject> debug_global(debug_context()->global_object());
  Handle<JSFunction> check_break_point =
    Handle<JSFunction>::cast(Object::GetProperty(
        debug_global, is_break_point_triggered_string).ToHandleChecked());
 
  // Get the break id as an object.
  Handle<Object> break_id = factory->NewNumberFromInt(Debug::break_id());
 
  // Call HandleBreakPointx.
  Handle<Object> argv[] = { break_id, break_point_object };
  Handle<Object> result;
  if (!Execution::TryCall(check_break_point,
                          isolate_->js_builtins_object(),
                          arraysize(argv),
                          argv).ToHandle(&result)) {
    return false;
  }
 
  // Return whether the break point is triggered.
  return result->IsTrue();
}

References arraysize, break_id(), v8::internal::Handle< T >::cast(), debug_context(), v8::internal::Isolate::factory(), v8::internal::Object::GetProperty(), isolate_, v8::internal::Isolate::js_builtins_object(), and STATIC_CHAR_VECTOR.

Referenced by CheckBreakPoints().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckBreakPoints()

Handle< Object > v8::internal::Debug::CheckBreakPoints ( Handle< Object >  break_point )

private

Definition at line 991 of file debug.cc.

                                                                         {
  Factory* factory = isolate_->factory();
 
  // Count the number of break points hit. If there are multiple break points
  // they are in a FixedArray.
  Handle<FixedArray> break_points_hit;
  int break_points_hit_count = 0;
  DCHECK(!break_point_objects->IsUndefined());
  if (break_point_objects->IsFixedArray()) {
    Handle<FixedArray> array(FixedArray::cast(*break_point_objects));
    break_points_hit = factory->NewFixedArray(array->length());
    for (int i = 0; i < array->length(); i++) {
      Handle<Object> o(array->get(i), isolate_);
      if (CheckBreakPoint(o)) {
        break_points_hit->set(break_points_hit_count++, *o);
      }
    }
  } else {
    break_points_hit = factory->NewFixedArray(1);
    if (CheckBreakPoint(break_point_objects)) {
      break_points_hit->set(break_points_hit_count++, *break_point_objects);
    }
  }
 
  // Return undefined if no break points were triggered.
  if (break_points_hit_count == 0) {
    return factory->undefined_value();
  }
  // Return break points hit as a JSArray.
  Handle<JSArray> result = factory->NewJSArrayWithElements(break_points_hit);
  result->set_length(Smi::FromInt(break_points_hit_count));
  return result;
}

References CheckBreakPoint(), DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), and isolate_.

Referenced by Break().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearAllBreakPoints()

void v8::internal::Debug::ClearAllBreakPoints

(

)

Definition at line 1181 of file debug.cc.

                                {
  DebugInfoListNode* node = debug_info_list_;
  while (node != NULL) {
    // Remove all debug break code.
    BreakLocationIterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
    it.ClearAllDebugBreak();
    node = node->next();
  }
 
  // Remove all debug info.
  while (debug_info_list_ != NULL) {
    RemoveDebugInfo(debug_info_list_->debug_info());
  }
}

References v8::internal::ALL_BREAK_LOCATIONS, v8::internal::BreakLocationIterator::ClearAllDebugBreak(), v8::internal::DebugInfoListNode::debug_info(), debug_info_list_, v8::internal::DebugInfoListNode::next(), NULL, and RemoveDebugInfo().

Referenced by Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearBreakPoint()

void v8::internal::Debug::ClearBreakPoint

(

Handle< Object >

break_point_object

)

Definition at line 1150 of file debug.cc.

                                                             {
  HandleScope scope(isolate_);
 
  DebugInfoListNode* node = debug_info_list_;
  while (node != NULL) {
    Object* result = DebugInfo::FindBreakPointInfo(node->debug_info(),
                                                   break_point_object);
    if (!result->IsUndefined()) {
      // Get information in the break point.
      BreakPointInfo* break_point_info = BreakPointInfo::cast(result);
      Handle<DebugInfo> debug_info = node->debug_info();
 
      // Find the break point and clear it.
      BreakLocationIterator it(debug_info, SOURCE_BREAK_LOCATIONS);
      it.FindBreakLocationFromAddress(debug_info->code()->entry() +
          break_point_info->code_position()->value());
      it.ClearBreakPoint(break_point_object);
 
      // If there are no more break points left remove the debug info for this
      // function.
      if (debug_info->GetBreakPointCount() == 0) {
        RemoveDebugInfo(debug_info);
      }
 
      return;
    }
    node = node->next();
  }
}

References v8::internal::BreakLocationIterator::ClearBreakPoint(), v8::internal::DebugInfoListNode::debug_info(), debug_info_list_, v8::internal::BreakLocationIterator::FindBreakLocationFromAddress(), v8::internal::DebugInfo::FindBreakPointInfo(), isolate_, v8::internal::DebugInfoListNode::next(), NULL, RemoveDebugInfo(), and v8::internal::SOURCE_BREAK_LOCATIONS.

Here is the call graph for this function:

ClearMirrorCache()

void v8::internal::Debug::ClearMirrorCache ( )

private

Definition at line 2389 of file debug.cc.

                             {
  PostponeInterruptsScope postpone(isolate_);
  HandleScope scope(isolate_);
  AssertDebugContext();
  Factory* factory = isolate_->factory();
  Handle<GlobalObject> global(isolate_->global_object());
  JSObject::SetProperty(global,
                        factory->NewStringFromAsciiChecked("next_handle_"),
                        handle(Smi::FromInt(0), isolate_), SLOPPY).Check();
  JSObject::SetProperty(global,
                        factory->NewStringFromAsciiChecked("mirror_cache_"),
                        factory->NewJSArray(0, FAST_ELEMENTS), SLOPPY).Check();
}

References AssertDebugContext(), v8::internal::Isolate::factory(), v8::internal::FAST_ELEMENTS, v8::internal::Smi::FromInt(), v8::internal::Isolate::global_object(), v8::internal::handle(), isolate_, v8::internal::Object::SetProperty(), and v8::internal::SLOPPY.

Here is the call graph for this function:

ClearOneShot()

void v8::internal::Debug::ClearOneShot ( )

private

Definition at line 1658 of file debug.cc.

                         {
  // The current implementation just runs through all the breakpoints. When the
  // last break point for a function is removed that function is automatically
  // removed from the list.
 
  DebugInfoListNode* node = debug_info_list_;
  while (node != NULL) {
    BreakLocationIterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
    while (!it.Done()) {
      it.ClearOneShot();
      it.Next();
    }
    node = node->next();
  }
}

References v8::internal::ALL_BREAK_LOCATIONS, v8::internal::BreakLocationIterator::ClearOneShot(), v8::internal::DebugInfoListNode::debug_info(), debug_info_list_, v8::internal::BreakLocationIterator::Done(), v8::internal::BreakLocationIterator::Next(), v8::internal::DebugInfoListNode::next(), and NULL.

Referenced by ClearStepping().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearStepIn()

void v8::internal::Debug::ClearStepIn ( )

private

Definition at line 1681 of file debug.cc.

                        {
  thread_local_.step_into_fp_ = 0;
}

References v8::internal::Debug::ThreadLocal::step_into_fp_, and thread_local_.

Referenced by ClearStepping().

Here is the caller graph for this function:

ClearStepNext()

void v8::internal::Debug::ClearStepNext ( )

private

Definition at line 1697 of file debug.cc.

                          {
  thread_local_.last_step_action_ = StepNone;
  thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
  thread_local_.last_fp_ = 0;
}

References v8::internal::RelocInfo::kNoPosition, v8::internal::Debug::ThreadLocal::last_fp_, v8::internal::Debug::ThreadLocal::last_statement_position_, v8::internal::Debug::ThreadLocal::last_step_action_, v8::internal::StepNone, and thread_local_.

Referenced by ClearStepping().

Here is the caller graph for this function:

ClearStepOut()

void v8::internal::Debug::ClearStepOut

(

)

Definition at line 1692 of file debug.cc.

                         {
  thread_local_.step_out_fp_ = 0;
}

References v8::internal::Debug::ThreadLocal::step_out_fp_, and thread_local_.

Referenced by ClearStepping(), and v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

ClearStepping()

void v8::internal::Debug::ClearStepping

(

)

Definition at line 1643 of file debug.cc.

                          {
  // Clear the various stepping setup.
  ClearOneShot();
  ClearStepIn();
  ClearStepOut();
  ClearStepNext();
 
  // Clear multiple step counter.
  thread_local_.step_count_ = 0;
}

References ClearOneShot(), ClearStepIn(), ClearStepNext(), ClearStepOut(), v8::internal::Debug::ThreadLocal::step_count_, and thread_local_.

Referenced by Break(), v8::internal::DebugEvaluate(), v8::internal::Invoke(), OnException(), and Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileDebuggerScript()

bool v8::internal::Debug::CompileDebuggerScript ( Isolate *  isolate, int  index  )

staticprivate

Definition at line 728 of file debug.cc.

                                                             {
  Factory* factory = isolate->factory();
  HandleScope scope(isolate);
 
  // Bail out if the index is invalid.
  if (index == -1) return false;
 
  // Find source and name for the requested script.
  Handle<String> source_code =
      isolate->bootstrapper()->NativesSourceLookup(index);
  Vector<const char> name = Natives::GetScriptName(index);
  Handle<String> script_name =
      factory->NewStringFromAscii(name).ToHandleChecked();
  Handle<Context> context = isolate->native_context();
 
  // Compile the script.
  Handle<SharedFunctionInfo> function_info;
  function_info = Compiler::CompileScript(
      source_code, script_name, 0, 0, false, context, NULL, NULL,
      ScriptCompiler::kNoCompileOptions, NATIVES_CODE);
 
  // Silently ignore stack overflows during compilation.
  if (function_info.is_null()) {
    DCHECK(isolate->has_pending_exception());
    isolate->clear_pending_exception();
    return false;
  }
 
  // Execute the shared function in the debugger context.
  Handle<JSFunction> function =
      factory->NewFunctionFromSharedFunctionInfo(function_info, context);
 
  MaybeHandle<Object> maybe_exception;
  MaybeHandle<Object> result = Execution::TryCall(
      function, handle(context->global_proxy()), 0, NULL, &maybe_exception);
 
  // Check for caught exceptions.
  if (result.is_null()) {
    DCHECK(!isolate->has_pending_exception());
    MessageLocation computed_location;
    isolate->ComputeLocation(&computed_location);
    Handle<Object> message = MessageHandler::MakeMessageObject(
        isolate, "error_loading_debugger", &computed_location,
        Vector<Handle<Object> >::empty(), Handle<JSArray>());
    DCHECK(!isolate->has_pending_exception());
    Handle<Object> exception;
    if (maybe_exception.ToHandle(&exception)) {
      isolate->set_pending_exception(*exception);
      MessageHandler::ReportMessage(isolate, NULL, message);
      isolate->clear_pending_exception();
    }
    return false;
  }
 
  // Mark this script as native and return successfully.
  Handle<Script> script(Script::cast(function->shared()->script()));
  script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
  return true;
}

References v8::internal::Isolate::bootstrapper(), v8::internal::Isolate::clear_pending_exception(), v8::internal::Compiler::CompileScript(), v8::internal::Isolate::ComputeLocation(), DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::NativesCollection< type >::GetScriptName(), v8::internal::handle(), v8::internal::Isolate::has_pending_exception(), v8::internal::MaybeHandle< T >::is_null(), v8::internal::Handle< T >::is_null(), v8::ScriptCompiler::kNoCompileOptions, v8::internal::MessageHandler::MakeMessageObject(), name, v8::internal::Isolate::native_context(), v8::internal::NATIVES_CODE, NULL, v8::internal::MessageHandler::ReportMessage(), v8::internal::Isolate::set_pending_exception(), and v8::internal::Script::TYPE_NATIVE.

Referenced by Load().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_context()

Handle<Context> v8::internal::Debug::debug_context ( )

inline

Definition at line 459 of file debug.h.

{ return debug_context_; }

References debug_context_.

Referenced by AssertDebugContext(), Call(), CheckBreakPoint(), v8::internal::CheckExecutionState(), v8::internal::Isolate::GetCallingNativeContext(), GetDebugContext(), v8::Debug::GetMirror(), v8::Shell::InstallUtilityScript(), IsDebugGlobal(), MakeJSObject(), and OnAfterCompile().

Here is the caller graph for this function:

debugger_entry()

DebugScope* v8::internal::Debug::debugger_entry ( )

inline

Definition at line 458 of file debug.h.

{ return thread_local_.current_debug_scope_; }

References v8::internal::Debug::ThreadLocal::current_debug_scope_, and thread_local_.

Referenced by v8::internal::GetDebugEventContext().

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::Debug::DISALLOW_COPY_AND_ASSIGN ( Debug  )

private

EnqueueCommandMessage()

void v8::internal::Debug::EnqueueCommandMessage	(	Vector< const uint16_t >	command,
		v8::Debug::ClientData *	client_data = NULL
	)

Definition at line 2979 of file debug.cc.

                                                                  {
  // Need to cast away const.
  CommandMessage message = CommandMessage::New(
      Vector<uint16_t>(const_cast<uint16_t*>(command.start()),
                       command.length()),
      client_data);
  isolate_->logger()->DebugTag("Put command on command_queue.");
  command_queue_.Put(message);
  command_received_.Signal();
 
  // Set the debug command break flag to have the command processed.
  if (!in_debug_scope()) isolate_->stack_guard()->RequestDebugCommand();
}

References command_queue_, command_received_, v8::internal::Logger::DebugTag(), in_debug_scope(), isolate_, v8::internal::Vector< T >::length(), v8::internal::Isolate::logger(), v8::internal::CommandMessage::New(), v8::internal::Isolate::stack_guard(), and v8::internal::Vector< T >::start().

Referenced by v8::Debug::SendCommand(), and SetMessageHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

EnqueueDebugCommand()

void v8::internal::Debug::EnqueueDebugCommand

(

v8::Debug::ClientData *

client_data = NULL

)

Definition at line 2995 of file debug.cc.

                                                              {
  CommandMessage message = CommandMessage::New(Vector<uint16_t>(), client_data);
  event_command_queue_.Put(message);
 
  // Set the debug command break flag to have the command processed.
  if (!in_debug_scope()) isolate_->stack_guard()->RequestDebugCommand();
}

References event_command_queue_, in_debug_scope(), isolate_, v8::internal::CommandMessage::New(), and v8::internal::Isolate::stack_guard().

Referenced by v8::Debug::DebugBreakForCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureDebugInfo()

bool v8::internal::Debug::EnsureDebugInfo	(	Handle< SharedFunctionInfo >	shared,
		Handle< JSFunction >	function
	)

Definition at line 2177 of file debug.cc.

                                                         {
  Isolate* isolate = shared->GetIsolate();
 
  // Return if we already have the debug info for shared.
  if (HasDebugInfo(shared)) {
    DCHECK(shared->is_compiled());
    return true;
  }
 
  // There will be at least one break point when we are done.
  has_break_points_ = true;
 
  // Ensure function is compiled. Return false if this failed.
  if (!function.is_null() &&
      !Compiler::EnsureCompiled(function, CLEAR_EXCEPTION)) {
    return false;
  }
 
  // Create the debug info object.
  Handle<DebugInfo> debug_info = isolate->factory()->NewDebugInfo(shared);
 
  // Add debug info to the list.
  DebugInfoListNode* node = new DebugInfoListNode(*debug_info);
  node->set_next(debug_info_list_);
  debug_info_list_ = node;
 
  return true;
}

References v8::internal::CLEAR_EXCEPTION, DCHECK, debug_info_list_, v8::internal::Compiler::EnsureCompiled(), v8::internal::Isolate::factory(), has_break_points_, HasDebugInfo(), and v8::internal::DebugInfoListNode::set_next().

Referenced by FloodWithOneShot(), IsBreakAtReturn(), PrepareStep(), v8::internal::ScopeIterator::ScopeIterator(), SetAfterBreakTarget(), SetBreakPoint(), and SetBreakPointForScript().

Here is the call graph for this function:

Here is the caller graph for this function:

FindSharedFunctionInfoInScript()

Object * v8::internal::Debug::FindSharedFunctionInfoInScript	(	Handle< Script >	script,
		int	position
	)

Definition at line 2071 of file debug.cc.

                                                            {
  // 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();
  while (!done) {
    { // Extra scope for iterator.
      HeapIterator iterator(heap);
      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;
              }
            }
          }
        }
      }  // End for loop.
    }  // End no-allocation scope.
 
    if (target.is_null()) return heap->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();
    if (!done) {
      // 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 isolate_->heap()->undefined_value();
    }
  }  // End while loop.
 
  return *target;
}

References DCHECK, v8::internal::Compiler::GetUnoptimizedCode(), has_break_points_, v8::internal::Isolate::heap(), v8::internal::MaybeHandle< T >::is_null(), v8::internal::Handle< T >::is_null(), isolate_, v8::internal::RelocInfo::kNoPosition, and NULL.

Referenced by SetBreakPointForScript().

Here is the call graph for this function:

Here is the caller graph for this function:

FloodBoundFunctionWithOneShot()

void v8::internal::Debug::FloodBoundFunctionWithOneShot

(

Handle< JSFunction >

function

)

Definition at line 1216 of file debug.cc.

                                                                     {
  Handle<FixedArray> new_bindings(function->function_bindings());
  Handle<Object> bindee(new_bindings->get(JSFunction::kBoundFunctionIndex),
                        isolate_);
 
  if (!bindee.is_null() && bindee->IsJSFunction() &&
      !JSFunction::cast(*bindee)->IsFromNativeScript()) {
    Handle<JSFunction> bindee_function(JSFunction::cast(*bindee));
    Debug::FloodWithOneShot(bindee_function);
  }
}

References FloodWithOneShot(), v8::internal::Handle< T >::is_null(), isolate_, and v8::internal::JSFunction::kBoundFunctionIndex.

Referenced by HandleStepIn(), and PrepareStep().

Here is the call graph for this function:

Here is the caller graph for this function:

FloodHandlerWithOneShot()

void v8::internal::Debug::FloodHandlerWithOneShot

(

)

Definition at line 1229 of file debug.cc.

                                    {
  // Iterate through the JavaScript stack looking for handlers.
  StackFrame::Id id = break_frame_id();
  if (id == StackFrame::NO_ID) {
    // If there is no JavaScript stack don't do anything.
    return;
  }
  for (JavaScriptFrameIterator it(isolate_, id); !it.done(); it.Advance()) {
    JavaScriptFrame* frame = it.frame();
    if (frame->HasHandler()) {
      // Flood the function with the catch block with break points
      FloodWithOneShot(Handle<JSFunction>(frame->function()));
      return;
    }
  }
}

References break_frame_id(), FloodWithOneShot(), v8::internal::JavaScriptFrame::function(), and isolate_.

Referenced by PrepareStep().

Here is the call graph for this function:

Here is the caller graph for this function:

FloodWithOneShot()

void v8::internal::Debug::FloodWithOneShot

(

Handle< JSFunction >

function

)

Definition at line 1197 of file debug.cc.

                                                        {
  PrepareForBreakPoints();
 
  // 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.
    return;
  }
 
  // Flood the function with break points.
  BreakLocationIterator it(GetDebugInfo(shared), ALL_BREAK_LOCATIONS);
  while (!it.Done()) {
    it.SetOneShot();
    it.Next();
  }
}

References v8::internal::ALL_BREAK_LOCATIONS, v8::internal::BreakLocationIterator::Done(), EnsureDebugInfo(), GetDebugInfo(), v8::internal::BreakLocationIterator::Next(), PrepareForBreakPoints(), and v8::internal::BreakLocationIterator::SetOneShot().

Referenced by FloodBoundFunctionWithOneShot(), FloodHandlerWithOneShot(), HandleStepIn(), PrepareStep(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

FramesHaveBeenDropped()

void v8::internal::Debug::FramesHaveBeenDropped	(	StackFrame::Id	new_break_frame_id,
		LiveEdit::FrameDropMode	mode,
		Object **	restarter_frame_function_pointer
	)

Definition at line 2372 of file debug.cc.

                                                                             {
  if (mode != LiveEdit::CURRENTLY_SET_MODE) {
    thread_local_.frame_drop_mode_ = mode;
  }
  thread_local_.break_frame_id_ = new_break_frame_id;
  thread_local_.restarter_frame_function_pointer_ =
      restarter_frame_function_pointer;
}

References v8::internal::Debug::ThreadLocal::break_frame_id_, v8::internal::LiveEdit::CURRENTLY_SET_MODE, v8::internal::Debug::ThreadLocal::frame_drop_mode_, mode(), v8::internal::Debug::ThreadLocal::restarter_frame_function_pointer_, and thread_local_.

Referenced by v8::internal::DropActivationsInActiveThreadImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeThreadResources()

void v8::internal::Debug::FreeThreadResources ( )

inline

Definition at line 452 of file debug.h.

{ }

Referenced by v8::internal::ThreadManager::FreeThreadResources().

Here is the caller graph for this function:

GetDebugContext()

Handle< Context > v8::internal::Debug::GetDebugContext

(

)

Definition at line 2778 of file debug.cc.

                                       {
  DebugScope debug_scope(this);
  // The global handle may be destroyed soon after.  Return it reboxed.
  return handle(*debug_context(), isolate_);
}

References debug_context(), DebugScope, v8::internal::handle(), and isolate_.

Here is the call graph for this function:

GetDebugInfo()

Handle< DebugInfo > v8::internal::Debug::GetDebugInfo ( Handle< SharedFunctionInfo >  shared )

static

Definition at line 1069 of file debug.cc.

                                                                       {
  DCHECK(HasDebugInfo(shared));
  return Handle<DebugInfo>(DebugInfo::cast(shared->debug_info()));
}

References DCHECK, and HasDebugInfo().

Referenced by Break(), FloodWithOneShot(), v8::internal::IC::GetOriginalCode(), GetSourceBreakLocations(), IsBreakAtReturn(), PrepareStep(), v8::internal::RUNTIME_FUNCTION(), v8::internal::ScopeIterator::ScopeIterator(), SetAfterBreakTarget(), SetBreakPoint(), and SetBreakPointForScript().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLoadedScripts()

Handle< FixedArray > v8::internal::Debug::GetLoadedScripts

(

)

Definition at line 2404 of file debug.cc.

                                           {
  // Create and fill the script cache when the loaded scripts is requested for
  // the first time.
  if (script_cache_ == NULL) script_cache_ = new ScriptCache(isolate_);
 
  // Perform GC to get unreferenced scripts evicted from the cache before
  // returning the content.
  isolate_->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                      "Debug::GetLoadedScripts");
 
  // Get the scripts from the cache.
  return script_cache_->GetScripts();
}

References v8::internal::Heap::CollectAllGarbage(), v8::internal::ScriptCache::GetScripts(), v8::internal::Isolate::heap(), isolate_, v8::internal::Heap::kNoGCFlags, NULL, and script_cache_.

Here is the call graph for this function:

GetSourceBreakLocations()

Handle< Object > v8::internal::Debug::GetSourceBreakLocations ( Handle< SharedFunctionInfo >  shared, BreakPositionAlignment  position_aligment  )

static

Definition at line 1551 of file debug.cc.

                                               {
  Isolate* isolate = shared->GetIsolate();
  Heap* heap = isolate->heap();
  if (!HasDebugInfo(shared)) {
    return Handle<Object>(heap->undefined_value(), isolate);
  }
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
  if (debug_info->GetBreakPointCount() == 0) {
    return Handle<Object>(heap->undefined_value(), isolate);
  }
  Handle<FixedArray> locations =
      isolate->factory()->NewFixedArray(debug_info->GetBreakPointCount());
  int count = 0;
  for (int i = 0; i < debug_info->break_points()->length(); i++) {
    if (!debug_info->break_points()->get(i)->IsUndefined()) {
      BreakPointInfo* break_point_info =
          BreakPointInfo::cast(debug_info->break_points()->get(i));
      if (break_point_info->GetBreakPointCount() > 0) {
        Smi* position;
        switch (position_alignment) {
        case STATEMENT_ALIGNED:
          position = break_point_info->statement_position();
          break;
        case BREAK_POSITION_ALIGNED:
          position = break_point_info->source_position();
          break;
        default:
          UNREACHABLE();
          position = break_point_info->statement_position();
        }
 
        locations->set(count++, position);
      }
    }
  }
  return locations;
}

References v8::internal::BREAK_POSITION_ALIGNED, v8::internal::Isolate::factory(), v8::internal::BreakPointInfo::GetBreakPointCount(), GetDebugInfo(), HasDebugInfo(), v8::internal::Isolate::heap(), v8::internal::STATEMENT_ALIGNED, and UNREACHABLE.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleDebugBreak()

void v8::internal::Debug::HandleDebugBreak

(

)

Definition at line 3024 of file debug.cc.

                             {
  // Ignore debug break during bootstrapping.
  if (isolate_->bootstrapper()->IsActive()) return;
  // Just continue if breaks are disabled.
  if (break_disabled_) return;
  // Ignore debug break if debugger is not active.
  if (!is_active()) return;
 
  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)->IsBuiltin()) return;
      GlobalObject* global = JSFunction::cast(fun)->context()->global_object();
      // Don't stop in debugger functions.
      if (IsDebugGlobal(global)) return;
    }
  }
 
  // Collect the break state before clearing the flags.
  bool debug_command_only = isolate_->stack_guard()->CheckDebugCommand() &&
                            !isolate_->stack_guard()->CheckDebugBreak();
 
  isolate_->stack_guard()->ClearDebugBreak();
 
  ProcessDebugMessages(debug_command_only);
}

References v8::internal::Isolate::bootstrapper(), break_disabled_, DCHECK, is_active(), IsDebugGlobal(), isolate_, ProcessDebugMessages(), and v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

HandleStepIn()

void v8::internal::Debug::HandleStepIn	(	Handle< JSFunction >	function,
		Handle< Object >	holder,
		Address	fp,
		bool	is_constructor
	)

Definition at line 1593 of file debug.cc.

                                              {
  Isolate* isolate = function->GetIsolate();
  // If the frame pointer is not supplied by the caller find it.
  if (fp == 0) {
    StackFrameIterator it(isolate);
    it.Advance();
    // For constructor functions skip another frame.
    if (is_constructor) {
      DCHECK(it.frame()->is_construct());
      it.Advance();
    }
    fp = it.frame()->fp();
  }
 
  // Flood the function with one-shot break points if it is called from where
  // step into was requested.
  if (fp == thread_local_.step_into_fp_) {
    if (function->shared()->bound()) {
      // Handle Function.prototype.bind
      Debug::FloodBoundFunctionWithOneShot(function);
    } else if (!function->IsFromNativeScript()) {
      // Don't allow step into functions in the native context.
      if (function->shared()->code() ==
          isolate->builtins()->builtin(Builtins::kFunctionApply) ||
          function->shared()->code() ==
          isolate->builtins()->builtin(Builtins::kFunctionCall)) {
        // Handle function.apply and function.call separately to flood the
        // function to be called and not the code for Builtins::FunctionApply or
        // Builtins::FunctionCall. The receiver of call/apply is the target
        // function.
        if (!holder.is_null() && holder->IsJSFunction()) {
          Handle<JSFunction> js_function = Handle<JSFunction>::cast(holder);
          if (!js_function->IsFromNativeScript()) {
            Debug::FloodWithOneShot(js_function);
          } else if (js_function->shared()->bound()) {
            // Handle Function.prototype.bind
            Debug::FloodBoundFunctionWithOneShot(js_function);
          }
        }
      } else {
        Debug::FloodWithOneShot(function);
      }
    }
  }
}

References v8::internal::StackFrameIterator::Advance(), v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), v8::internal::Handle< T >::cast(), DCHECK, FloodBoundFunctionWithOneShot(), FloodWithOneShot(), v8::internal::fp, v8::internal::StackFrameIterator::frame(), v8::internal::Handle< T >::is_null(), v8::internal::Debug::ThreadLocal::step_into_fp_, and thread_local_.

Referenced by v8::internal::Object::GetPropertyWithDefinedGetter(), v8::internal::Runtime_NewObjectHelper(), and v8::internal::Object::SetPropertyWithDefinedSetter().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleWeakDebugInfo()

void v8::internal::Debug::HandleWeakDebugInfo ( const v8::WeakCallbackData< v8::Value, void > &  data )

static

Definition at line 691 of file debug.cc.

                                                   {
  Debug* debug = reinterpret_cast<Isolate*>(data.GetIsolate())->debug();
  DebugInfoListNode* node =
      reinterpret_cast<DebugInfoListNode*>(data.GetParameter());
  // We need to clear all breakpoints associated with the function to restore
  // original code and avoid patching the code twice later because
  // the function will live in the heap until next gc, and can be found by
  // Debug::FindSharedFunctionInfoInScript.
  BreakLocationIterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
  it.ClearAllDebugBreak();
  debug->RemoveDebugInfo(node->debug_info());
#ifdef DEBUG
  for (DebugInfoListNode* n = debug->debug_info_list_;
       n != NULL;
       n = n->next()) {
    DCHECK(n != node);
  }
#endif
}

References v8::internal::ALL_BREAK_LOCATIONS, v8::internal::BreakLocationIterator::ClearAllDebugBreak(), DCHECK, v8::internal::DebugInfoListNode::debug_info(), debug_info_list_, v8::WeakCallbackData< T, P >::GetIsolate(), v8::WeakCallbackData< T, P >::GetParameter(), NULL, and RemoveDebugInfo().

Referenced by v8::internal::DebugInfoListNode::DebugInfoListNode().

Here is the call graph for this function:

Here is the caller graph for this function:

has_break_points()

bool v8::internal::Debug::has_break_points ( ) const

inline

Definition at line 467 of file debug.h.

{ return has_break_points_; }

References has_break_points_.

Referenced by v8::internal::IC::address(), v8::internal::IC::constant_pool(), and v8::internal::RelocInfo::Visit().

Here is the caller graph for this function:

has_commands()

bool v8::internal::Debug::has_commands ( ) const

inlineprivate

Definition at line 504 of file debug.h.

{ return !command_queue_.IsEmpty(); }

References command_queue_.

Referenced by NotifyMessageHandler().

Here is the caller graph for this function:

HasDebugInfo()

bool v8::internal::Debug::HasDebugInfo ( Handle< SharedFunctionInfo >  shared )

static

Definition at line 1062 of file debug.cc.

                                                          {
  return !shared->debug_info()->IsUndefined();
}

Referenced by EnsureDebugInfo(), GetDebugInfo(), v8::internal::IC::GetOriginalCode(), and GetSourceBreakLocations().

Here is the caller graph for this function:

ignore_events()

bool v8::internal::Debug::ignore_events ( ) const

inlineprivate

Definition at line 505 of file debug.h.

{ return is_suppressed_ || !is_active_; }

References is_active_, and is_suppressed_.

Referenced by OnAfterCompile(), OnAsyncTaskEvent(), OnBeforeCompile(), OnCompileError(), OnDebugBreak(), OnPromiseEvent(), OnPromiseReject(), and OnThrow().

Here is the caller graph for this function:

in_debug_scope()

bool v8::internal::Debug::in_debug_scope ( ) const

inline

Definition at line 468 of file debug.h.

                                     {
    return thread_local_.current_debug_scope_ != NULL;
  }

References v8::internal::Debug::ThreadLocal::current_debug_scope_, NULL, and thread_local_.

Referenced by AssertDebugContext(), EnqueueCommandMessage(), EnqueueDebugCommand(), v8::internal::Isolate::GetCallingNativeContext(), NotifyMessageHandler(), OnAfterCompile(), OnAsyncTaskEvent(), OnBeforeCompile(), OnCompileError(), OnPromiseEvent(), OnPromiseReject(), OnThrow(), PrepareStep(), SetMessageHandler(), and UpdateState().

Here is the caller graph for this function:

InvokeMessageHandler()

void v8::internal::Debug::InvokeMessageHandler ( MessageImpl  message )

private

Definition at line 2970 of file debug.cc.

                                                    {
  if (message_handler_ != NULL) message_handler_(message);
}

References message_handler_, and NULL.

Referenced by NotifyMessageHandler().

Here is the caller graph for this function:

is_active()

bool v8::internal::Debug::is_active ( ) const

inline

Definition at line 465 of file debug.h.

{ return is_active_; }

References is_active_.

Referenced by HandleDebugBreak(), v8::internal::CompilationInfo::Initialize(), v8::internal::Invoke(), and NotifyMessageHandler().

Here is the caller graph for this function:

is_active_address()

Address v8::internal::Debug::is_active_address ( )

inline

Definition at line 477 of file debug.h.

                              {
    return reinterpret_cast<Address>(&is_active_);
  }

References is_active_.

is_loaded()

bool v8::internal::Debug::is_loaded ( ) const

inline

Definition at line 466 of file debug.h.

{ return !debug_context_.is_null(); }

References debug_context_.

Referenced by v8::internal::Compiler::CompileScript(), IsDebugGlobal(), Load(), Unload(), and UpdateState().

Here is the caller graph for this function:

IsBreakAtReturn()

bool v8::internal::Debug::IsBreakAtReturn

(

JavaScriptFrame *

frame

)

Definition at line 2329 of file debug.cc.

                                                  {
  HandleScope scope(isolate_);
 
  // If there are no break points this cannot be break at return, as
  // the debugger statement and stack guard bebug break cannot be at
  // return.
  if (!has_break_points_) {
    return false;
  }
 
  PrepareForBreakPoints();
 
  // Get the executing function in which the debug break occurred.
  Handle<JSFunction> function(JSFunction::cast(frame->function()));
  Handle<SharedFunctionInfo> shared(function->shared());
  if (!EnsureDebugInfo(shared, function)) {
    // Return if we failed to retrieve the debug info.
    return false;
  }
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
  Handle<Code> code(debug_info->code());
#ifdef DEBUG
  // Get the code which is actually executing.
  Handle<Code> frame_code(frame->LookupCode());
  DCHECK(frame_code.is_identical_to(code));
#endif
 
  // Find the call address in the running code.
  Address addr = Assembler::break_address_from_return_address(frame->pc());
 
  // Check if the location is at JS return.
  RelocIterator it(debug_info->code());
  while (!it.done()) {
    if (RelocInfo::IsJSReturn(it.rinfo()->rmode())) {
      return (it.rinfo()->pc() ==
          addr - Assembler::kPatchReturnSequenceAddressOffset);
    }
    it.next();
  }
  return false;
}

References v8::internal::Assembler::break_address_from_return_address(), DCHECK, v8::internal::RelocIterator::done(), EnsureDebugInfo(), v8::internal::JavaScriptFrame::function(), GetDebugInfo(), has_break_points_, v8::internal::RelocInfo::IsJSReturn(), isolate_, v8::internal::Assembler::kPatchReturnSequenceAddressOffset, v8::internal::RelocIterator::next(), v8::internal::RelocInfo::pc(), PrepareForBreakPoints(), v8::internal::RelocIterator::rinfo(), and v8::internal::RelocInfo::rmode().

Here is the call graph for this function:

IsBreakOnException()

bool v8::internal::Debug::IsBreakOnException

(

ExceptionBreakType

type

)

Definition at line 1256 of file debug.cc.

                                                      {
  if (type == BreakUncaughtException) {
    return break_on_uncaught_exception_;
  } else {
    return break_on_exception_;
  }
}

References break_on_exception_, break_on_uncaught_exception_, and v8::internal::BreakUncaughtException.

IsDebugBreak()

bool v8::internal::Debug::IsDebugBreak ( Address  addr )

static

Definition at line 1541 of file debug.cc.

                                     {
  Code* code = Code::GetCodeFromTargetAddress(addr);
  return code->is_debug_stub() && code->extra_ic_state() == DEBUG_BREAK;
}

References v8::internal::DEBUG_BREAK, v8::internal::Code::extra_ic_state(), v8::internal::Code::GetCodeFromTargetAddress(), and v8::internal::Code::is_debug_stub().

Referenced by v8::internal::IC::address(), v8::internal::IC::constant_pool(), v8::internal::BreakLocationIterator::IsDebugBreak(), and SetAfterBreakTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDebugBreakAtReturn()

static bool v8::internal::Debug::IsDebugBreakAtReturn ( RelocInfo *  rinfo )

static

IsDebugGlobal()

bool v8::internal::Debug::IsDebugGlobal

(

GlobalObject *

global

)

Definition at line 2384 of file debug.cc.

                                              {
  return is_loaded() && global == debug_context()->global_object();
}

References debug_context(), and is_loaded().

Referenced by HandleDebugBreak(), and v8::internal::V8HeapExplorer::SetGcSubrootReference().

Here is the call graph for this function:

Here is the caller graph for this function:

IsStepping()

bool v8::internal::Debug::IsStepping ( )

inline

Definition at line 399 of file debug.h.

{ return thread_local_.step_count_ > 0; }

References v8::internal::Debug::ThreadLocal::step_count_, and thread_local_.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

live_edit_enabled()

bool v8::internal::Debug::live_edit_enabled ( ) const

inline

Definition at line 461 of file debug.h.

                                 {
    return FLAG_enable_liveedit && live_edit_enabled_ ;
  }

References live_edit_enabled_.

Load()

bool v8::internal::Debug::Load

(

)

Definition at line 789 of file debug.cc.

                 {
  // Return if debugger is already loaded.
  if (is_loaded()) return true;
 
  // Bail out if we're already in the process of compiling the native
  // JavaScript source code for the debugger.
  if (is_suppressed_) return false;
  SuppressDebug while_loading(this);
 
  // Disable breakpoints and interrupts while compiling and running the
  // debugger scripts including the context creation code.
  DisableBreak disable(this, true);
  PostponeInterruptsScope postpone(isolate_);
 
  // Create the debugger context.
  HandleScope scope(isolate_);
  ExtensionConfiguration no_extensions;
  Handle<Context> context =
      isolate_->bootstrapper()->CreateEnvironment(
          MaybeHandle<JSGlobalProxy>(),
          v8::Handle<ObjectTemplate>(),
          &no_extensions);
 
  // Fail if no context could be created.
  if (context.is_null()) return false;
 
  // Use the debugger context.
  SaveContext save(isolate_);
  isolate_->set_context(*context);
 
  // Expose the builtins object in the debugger context.
  Handle<String> key = isolate_->factory()->InternalizeOneByteString(
      STATIC_CHAR_VECTOR("builtins"));
  Handle<GlobalObject> global =
      Handle<GlobalObject>(context->global_object(), isolate_);
  Handle<JSBuiltinsObject> builtin =
      Handle<JSBuiltinsObject>(global->builtins(), isolate_);
  RETURN_ON_EXCEPTION_VALUE(
      isolate_, Object::SetProperty(global, key, builtin, SLOPPY), false);
 
  // Compile the JavaScript for the debugger in the debugger context.
  bool caught_exception =
      !CompileDebuggerScript(isolate_, Natives::GetIndex("mirror")) ||
      !CompileDebuggerScript(isolate_, Natives::GetIndex("debug"));
 
  if (FLAG_enable_liveedit) {
    caught_exception = caught_exception ||
        !CompileDebuggerScript(isolate_, Natives::GetIndex("liveedit"));
  }
  // Check for caught exceptions.
  if (caught_exception) return false;
 
  debug_context_ = Handle<Context>::cast(
      isolate_->global_handles()->Create(*context));
  return true;
}

References v8::internal::Isolate::bootstrapper(), v8::internal::Handle< T >::cast(), CompileDebuggerScript(), v8::internal::GlobalHandles::Create(), debug_context_, DisableBreak, v8::internal::Isolate::factory(), v8::internal::NativesCollection< type >::GetIndex(), v8::internal::Isolate::global_handles(), is_loaded(), v8::internal::Handle< T >::is_null(), is_suppressed_, isolate_, RETURN_ON_EXCEPTION_VALUE, v8::internal::Isolate::set_context(), v8::internal::Object::SetProperty(), v8::internal::SLOPPY, STATIC_CHAR_VECTOR, and SuppressDebug.

Referenced by v8::Debug::GetMirror(), v8::Shell::InstallUtilityScript(), and UpdateState().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeAsyncTaskEvent()

MaybeHandle< Object > v8::internal::Debug::MakeAsyncTaskEvent ( Handle< JSObject >  task_event )

private

Definition at line 2497 of file debug.cc.

                                                                         {
  // Create the async task event object.
  Handle<Object> argv[] = { task_event };
  return MakeJSObject("MakeAsyncTaskEvent", arraysize(argv), argv);
}

References arraysize, and MakeJSObject().

Referenced by OnAsyncTaskEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeBreakEvent()

MaybeHandle< Object > v8::internal::Debug::MakeBreakEvent ( Handle< Object >  break_points_hit )

private

Definition at line 2460 of file debug.cc.

                                                                         {
  // Create the new break event object.
  Handle<Object> argv[] = { isolate_->factory()->NewNumberFromInt(break_id()),
                            break_points_hit };
  return MakeJSObject("MakeBreakEvent", arraysize(argv), argv);
}

References arraysize, break_id(), v8::internal::Isolate::factory(), isolate_, and MakeJSObject().

Referenced by OnDebugBreak().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeCompileEvent()

MaybeHandle< Object > v8::internal::Debug::MakeCompileEvent ( Handle< Script >  script, v8::DebugEvent  type  )

private

Definition at line 2480 of file debug.cc.

                                                               {
  // Create the compile event object.
  Handle<Object> script_wrapper = Script::GetWrapper(script);
  Handle<Object> argv[] = { script_wrapper,
                            isolate_->factory()->NewNumberFromInt(type) };
  return MakeJSObject("MakeCompileEvent", arraysize(argv), argv);
}

References arraysize, v8::internal::Isolate::factory(), v8::internal::Script::GetWrapper(), isolate_, and MakeJSObject().

Referenced by OnAfterCompile(), OnBeforeCompile(), and OnCompileError().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeExceptionEvent()

MaybeHandle< Object > v8::internal::Debug::MakeExceptionEvent ( Handle< Object >  exception, bool  uncaught, Handle< Object >  promise  )

private

Definition at line 2468 of file debug.cc.

                                                                      {
  // Create the new exception event object.
  Handle<Object> argv[] = { isolate_->factory()->NewNumberFromInt(break_id()),
                            exception,
                            isolate_->factory()->ToBoolean(uncaught),
                            promise };
  return MakeJSObject("MakeExceptionEvent", arraysize(argv), argv);
}

References arraysize, break_id(), v8::internal::Isolate::factory(), isolate_, and MakeJSObject().

Referenced by OnException().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeExecutionState()

MaybeHandle< Object > v8::internal::Debug::MakeExecutionState ( )

private

Definition at line 2453 of file debug.cc.

                                              {
  // Create the execution state object.
  Handle<Object> argv[] = { isolate_->factory()->NewNumberFromInt(break_id()) };
  return MakeJSObject("MakeExecutionState", arraysize(argv), argv);
}

References arraysize, break_id(), v8::internal::Isolate::factory(), isolate_, and MakeJSObject().

Referenced by Call(), and ProcessDebugEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeJSObject()

MaybeHandle< Object > v8::internal::Debug::MakeJSObject ( const char *  constructor_name, int  argc, Handle< Object >  argv[]  )

private

Definition at line 2434 of file debug.cc.

                                                               {
  AssertDebugContext();
  // Create the execution state object.
  Handle<GlobalObject> global(isolate_->global_object());
  Handle<Object> constructor = Object::GetProperty(
      isolate_, global, constructor_name).ToHandleChecked();
  DCHECK(constructor->IsJSFunction());
  if (!constructor->IsJSFunction()) return MaybeHandle<Object>();
  // We do not handle interrupts here.  In particular, termination interrupts.
  PostponeInterruptsScope no_interrupts(isolate_);
  return Execution::TryCall(Handle<JSFunction>::cast(constructor),
                            handle(debug_context()->global_proxy()),
                            argc,
                            argv);
}

References AssertDebugContext(), DCHECK, debug_context(), v8::internal::Object::GetProperty(), v8::internal::Isolate::global_object(), v8::internal::handle(), and isolate_.

Referenced by MakeAsyncTaskEvent(), MakeBreakEvent(), MakeCompileEvent(), MakeExceptionEvent(), MakeExecutionState(), and MakePromiseEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

MakePromiseEvent()

MaybeHandle< Object > v8::internal::Debug::MakePromiseEvent ( Handle< JSObject >  promise_event )

private

Definition at line 2490 of file debug.cc.

                                                                       {
  // Create the promise event object.
  Handle<Object> argv[] = { event_data };
  return MakeJSObject("MakePromiseEvent", arraysize(argv), argv);
}

References arraysize, and MakeJSObject().

Referenced by OnPromiseEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

NotifyMessageHandler()

void v8::internal::Debug::NotifyMessageHandler ( v8::DebugEvent  event, Handle< JSObject >  exec_state, Handle< JSObject >  event_data, bool  auto_continue  )

private

Definition at line 2785 of file debug.cc.

                                                     {
  // Prevent other interrupts from triggering, for example API callbacks,
  // while dispatching message handler callbacks.
  PostponeInterruptsScope no_interrupts(isolate_);
  DCHECK(is_active_);
  HandleScope scope(isolate_);
  // Process the individual events.
  bool sendEventMessage = false;
  switch (event) {
    case v8::Break:
    case v8::BreakForCommand:
      sendEventMessage = !auto_continue;
      break;
    case v8::Exception:
      sendEventMessage = true;
      break;
    case v8::BeforeCompile:
      break;
    case v8::AfterCompile:
      sendEventMessage = true;
      break;
    case v8::NewFunction:
      break;
    default:
      UNREACHABLE();
  }
 
  // The debug command interrupt flag might have been set when the command was
  // added. It should be enough to clear the flag only once while we are in the
  // debugger.
  DCHECK(in_debug_scope());
  isolate_->stack_guard()->ClearDebugCommand();
 
  // Notify the debugger that a debug event has occurred unless auto continue is
  // active in which case no event is send.
  if (sendEventMessage) {
    MessageImpl message = MessageImpl::NewEvent(
        event,
        auto_continue,
        Handle<JSObject>::cast(exec_state),
        Handle<JSObject>::cast(event_data));
    InvokeMessageHandler(message);
  }
 
  // If auto continue don't make the event cause a break, but process messages
  // in the queue if any. For script collected events don't even process
  // messages in the queue as the execution state might not be what is expected
  // by the client.
  if (auto_continue && !has_commands()) return;
 
  // DebugCommandProcessor goes here.
  bool running = auto_continue;
 
  Handle<Object> cmd_processor_ctor = Object::GetProperty(
      isolate_, exec_state, "debugCommandProcessor").ToHandleChecked();
  Handle<Object> ctor_args[] = { isolate_->factory()->ToBoolean(running) };
  Handle<Object> cmd_processor = Execution::Call(
      isolate_, cmd_processor_ctor, exec_state, 1, ctor_args).ToHandleChecked();
  Handle<JSFunction> process_debug_request = Handle<JSFunction>::cast(
      Object::GetProperty(
          isolate_, cmd_processor, "processDebugRequest").ToHandleChecked());
  Handle<Object> is_running = Object::GetProperty(
      isolate_, cmd_processor, "isRunning").ToHandleChecked();
 
  // Process requests from the debugger.
  do {
    // Wait for new command in the queue.
    command_received_.Wait();
 
    // Get the command from the queue.
    CommandMessage command = command_queue_.Get();
    isolate_->logger()->DebugTag(
        "Got request from command queue, in interactive loop.");
    if (!is_active()) {
      // Delete command text and user data.
      command.Dispose();
      return;
    }
 
    Vector<const uc16> command_text(
        const_cast<const uc16*>(command.text().start()),
        command.text().length());
    Handle<String> request_text = isolate_->factory()->NewStringFromTwoByte(
        command_text).ToHandleChecked();
    Handle<Object> request_args[] = { request_text };
    Handle<Object> answer_value;
    Handle<String> answer;
    MaybeHandle<Object> maybe_exception;
    MaybeHandle<Object> maybe_result =
        Execution::TryCall(process_debug_request, cmd_processor, 1,
                           request_args, &maybe_exception);
 
    if (maybe_result.ToHandle(&answer_value)) {
      if (answer_value->IsUndefined()) {
        answer = isolate_->factory()->empty_string();
      } else {
        answer = Handle<String>::cast(answer_value);
      }
 
      // Log the JSON request/response.
      if (FLAG_trace_debug_json) {
        PrintF("%s\n", request_text->ToCString().get());
        PrintF("%s\n", answer->ToCString().get());
      }
 
      Handle<Object> is_running_args[] = { answer };
      maybe_result = Execution::Call(
          isolate_, is_running, cmd_processor, 1, is_running_args);
      Handle<Object> result;
      if (!maybe_result.ToHandle(&result)) break;
      running = result->IsTrue();
    } else {
      Handle<Object> exception;
      if (!maybe_exception.ToHandle(&exception)) break;
      Handle<Object> result;
      if (!Execution::ToString(isolate_, exception).ToHandle(&result)) break;
      answer = Handle<String>::cast(result);
    }
 
    // Return the result.
    MessageImpl message = MessageImpl::NewResponse(
        event, running, exec_state, event_data, answer, command.client_data());
    InvokeMessageHandler(message);
    command.Dispose();
 
    // Return from debug event processing if either the VM is put into the
    // running state (through a continue command) or auto continue is active
    // and there are no more commands queued.
  } while (!running || has_commands());
  command_queue_.Clear();
}

References v8::AfterCompile, v8::BeforeCompile, v8::Break, v8::BreakForCommand, v8::internal::Handle< T >::cast(), v8::internal::CommandMessage::client_data(), command_queue_, command_received_, DCHECK, v8::internal::Logger::DebugTag(), v8::internal::CommandMessage::Dispose(), v8::Exception, v8::internal::Isolate::factory(), v8::internal::Object::GetProperty(), has_commands(), in_debug_scope(), InvokeMessageHandler(), is_active(), is_active_, isolate_, v8::internal::Vector< T >::length(), v8::internal::Isolate::logger(), v8::internal::MessageImpl::NewEvent(), v8::NewFunction, v8::internal::MessageImpl::NewResponse(), v8::internal::PrintF(), v8::internal::Isolate::stack_guard(), v8::internal::Vector< T >::start(), v8::internal::CommandMessage::text(), and UNREACHABLE.

Referenced by ProcessDebugEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAfterCompile()

void v8::internal::Debug::OnAfterCompile

(

Handle< Script >

script

)

Definition at line 2621 of file debug.cc.

                                                {
  // Add the newly compiled script to the script cache.
  if (script_cache_ != NULL) script_cache_->Add(script);
 
  // No more to do if not debugging.
  if (in_debug_scope() || ignore_events()) return;
 
  HandleScope scope(isolate_);
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // If debugging there might be script break points registered for this
  // script. Make sure that these break points are set.
 
  // Get the function UpdateScriptBreakPoints (defined in debug-debugger.js).
  Handle<String> update_script_break_points_string =
      isolate_->factory()->InternalizeOneByteString(
          STATIC_CHAR_VECTOR("UpdateScriptBreakPoints"));
  Handle<GlobalObject> debug_global(debug_context()->global_object());
  Handle<Object> update_script_break_points =
      Object::GetProperty(
          debug_global, update_script_break_points_string).ToHandleChecked();
  if (!update_script_break_points->IsJSFunction()) {
    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 };
  if (Execution::TryCall(Handle<JSFunction>::cast(update_script_break_points),
                         isolate_->js_builtins_object(),
                         arraysize(argv),
                         argv).is_null()) {
    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);
}

References v8::internal::ScriptCache::Add(), v8::AfterCompile, arraysize, DCHECK, debug_context(), DebugScope, v8::internal::Isolate::factory(), v8::internal::Object::GetProperty(), v8::internal::Script::GetWrapper(), ignore_events(), in_debug_scope(), isolate_, v8::internal::Isolate::js_builtins_object(), MakeCompileEvent(), NULL, ProcessDebugEvent(), script_cache_, and STATIC_CHAR_VECTOR.

Referenced by v8::internal::LiveEdit::ChangeScriptSource(), and v8::internal::CompileToplevel().

Here is the call graph for this function:

Here is the caller graph for this function:

OnAsyncTaskEvent()

void v8::internal::Debug::OnAsyncTaskEvent

(

Handle< JSObject >

data

)

Definition at line 2690 of file debug.cc.

                                                  {
  if (in_debug_scope() || ignore_events()) 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.
  if (!MakeAsyncTaskEvent(data).ToHandle(&event_data)) return;
 
  // Process debug event.
  ProcessDebugEvent(v8::AsyncTaskEvent,
                    Handle<JSObject>::cast(event_data),
                    true);
}

References v8::AsyncTaskEvent, DebugScope, ignore_events(), in_debug_scope(), isolate_, MakeAsyncTaskEvent(), and ProcessDebugEvent().

Here is the call graph for this function:

OnBeforeCompile()

void v8::internal::Debug::OnBeforeCompile

(

Handle< Script >

script

)

Definition at line 2600 of file debug.cc.

                                                 {
  if (in_debug_scope() || ignore_events()) return;
 
  HandleScope scope(isolate_);
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // Create the event data object.
  Handle<Object> event_data;
  // Bail out and don't call debugger if exception.
  if (!MakeCompileEvent(script, v8::BeforeCompile).ToHandle(&event_data))
    return;
 
  // Process debug event.
  ProcessDebugEvent(v8::BeforeCompile,
                    Handle<JSObject>::cast(event_data),
                    true);
}

References v8::BeforeCompile, DebugScope, ignore_events(), in_debug_scope(), isolate_, MakeCompileEvent(), and ProcessDebugEvent().

Referenced by v8::internal::CompileToplevel().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCompileError()

void v8::internal::Debug::OnCompileError

(

Handle< Script >

script

)

Definition at line 2562 of file debug.cc.

                                                {
  // No more to do if not debugging.
  if (in_debug_scope() || ignore_events()) return;
 
  HandleScope scope(isolate_);
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // Create the compile state object.
  Handle<Object> event_data;
  // Bail out and don't call debugger if exception.
  if (!MakeCompileEvent(script, v8::CompileError).ToHandle(&event_data)) return;
 
  // Process debug event.
  ProcessDebugEvent(v8::CompileError, Handle<JSObject>::cast(event_data), true);
}

References v8::CompileError, DebugScope, ignore_events(), in_debug_scope(), isolate_, MakeCompileEvent(), and ProcessDebugEvent().

Referenced by v8::internal::Parser::ThrowPendingError().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDebugBreak()

void v8::internal::Debug::OnDebugBreak	(	Handle< Object >	break_points_hit,
		bool	auto_continue
	)

Definition at line 2580 of file debug.cc.

                                                {
  // The caller provided for DebugScope.
  AssertDebugContext();
  // Bail out if there is no listener for this event
  if (ignore_events()) return;
 
  HandleScope scope(isolate_);
  // Create the event data object.
  Handle<Object> event_data;
  // Bail out and don't call debugger if exception.
  if (!MakeBreakEvent(break_points_hit).ToHandle(&event_data)) return;
 
  // Process debug event.
  ProcessDebugEvent(v8::Break,
                    Handle<JSObject>::cast(event_data),
                    auto_continue);
}

References AssertDebugContext(), v8::Break, ignore_events(), isolate_, MakeBreakEvent(), and ProcessDebugEvent().

Referenced by Break(), and ProcessDebugMessages().

Here is the call graph for this function:

Here is the caller graph for this function:

OnException()

void v8::internal::Debug::OnException ( Handle< Object >  exception, bool  uncaught, Handle< Object >  promise  )

private

Definition at line 2528 of file debug.cc.

                                                {
  if (promise->IsJSObject()) {
    uncaught |= !PromiseHasRejectHandler(Handle<JSObject>::cast(promise));
  }
  // 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;
  }
 
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // Clear all current stepping setup.
  ClearStepping();
 
  // 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), false);
  // Return to continue execution from where the exception was thrown.
}

References break_on_exception_, break_on_uncaught_exception_, ClearStepping(), DebugScope, MakeExceptionEvent(), ProcessDebugEvent(), and PromiseHasRejectHandler().

Referenced by OnPromiseReject(), and OnThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPromiseEvent()

void v8::internal::Debug::OnPromiseEvent

(

Handle< JSObject >

data

)

Definition at line 2671 of file debug.cc.

                                                {
  if (in_debug_scope() || ignore_events()) 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.
  if (!MakePromiseEvent(data).ToHandle(&event_data)) return;
 
  // Process debug event.
  ProcessDebugEvent(v8::PromiseEvent,
                    Handle<JSObject>::cast(event_data),
                    true);
}

References DebugScope, ignore_events(), in_debug_scope(), isolate_, MakePromiseEvent(), ProcessDebugEvent(), and v8::PromiseEvent.

Here is the call graph for this function:

OnPromiseReject()

void v8::internal::Debug::OnPromiseReject	(	Handle< JSObject >	promise,
		Handle< Object >	value
	)

Definition at line 2521 of file debug.cc.

                                                                          {
  if (in_debug_scope() || ignore_events()) return;
  HandleScope scope(isolate_);
  OnException(value, false, promise);
}

References ignore_events(), in_debug_scope(), isolate_, and OnException().

Here is the call graph for this function:

OnThrow()

void v8::internal::Debug::OnThrow	(	Handle< Object >	exception,
		bool	uncaught
	)

Definition at line 2504 of file debug.cc.

                                                           {
  if (in_debug_scope() || ignore_events()) return;
  // Temporarily clear any scheduled_exception to allow evaluating
  // JavaScript from the debug event handler.
  HandleScope scope(isolate_);
  Handle<Object> scheduled_exception;
  if (isolate_->has_scheduled_exception()) {
    scheduled_exception = handle(isolate_->scheduled_exception(), isolate_);
    isolate_->clear_scheduled_exception();
  }
  OnException(exception, uncaught, isolate_->GetPromiseOnStackOnThrow());
  if (!scheduled_exception.is_null()) {
    isolate_->thread_local_top()->scheduled_exception_ = *scheduled_exception;
  }
}

References v8::internal::Isolate::clear_scheduled_exception(), v8::internal::Isolate::GetPromiseOnStackOnThrow(), v8::internal::handle(), v8::internal::Isolate::has_scheduled_exception(), ignore_events(), in_debug_scope(), v8::internal::Handle< T >::is_null(), isolate_, OnException(), v8::internal::Isolate::scheduled_exception(), and v8::internal::Isolate::thread_local_top().

Referenced by v8::internal::Isolate::DoThrow().

Here is the call graph for this function:

Here is the caller graph for this function:

PrepareForBreakPoints()

void v8::internal::Debug::PrepareForBreakPoints

(

)

Definition at line 1907 of file debug.cc.

                                  {
  // If preparing for the first break point make sure to deoptimize all
  // functions as debugging does not work with optimized code.
  if (!has_break_points_) {
    if (isolate_->concurrent_recompilation_enabled()) {
      isolate_->optimizing_compiler_thread()->Flush();
    }
 
    Deoptimizer::DeoptimizeAll(isolate_);
 
    Handle<Code> lazy_compile = isolate_->builtins()->CompileLazy();
 
    // There will be at least one break point when we are done.
    has_break_points_ = true;
 
    // Keep the list of activated functions in a handlified list as it
    // is used both in GC and non-GC code.
    List<Handle<JSFunction> > active_functions(100);
 
    // A list of all suspended generators.
    List<Handle<JSGeneratorObject> > suspended_generators;
 
    // A list of all generator functions.  We need to recompile all functions,
    // but we don't know until after visiting the whole heap which generator
    // functions have suspended activations and which do not.  As in the case of
    // functions with activations on the stack, we need to be careful with
    // generator functions with suspended activations because although they
    // should be recompiled, recompilation can fail, and we need to avoid
    // leaving the heap in an inconsistent state.
    //
    // We could perhaps avoid this list and instead re-use the GC metadata
    // links.
    List<Handle<JSFunction> > generator_functions;
 
    {
      // We are going to iterate heap to find all functions without
      // debug break slots.
      Heap* heap = isolate_->heap();
      heap->CollectAllGarbage(Heap::kMakeHeapIterableMask,
                              "preparing for breakpoints");
      HeapIterator iterator(heap);
 
      // Ensure no GC in this scope as we are going to use gc_metadata
      // field in the Code object to mark active functions.
      DisallowHeapAllocation no_allocation;
 
      Object* active_code_marker = heap->the_hole_value();
 
      CollectActiveFunctionsFromThread(isolate_,
                                       isolate_->thread_local_top(),
                                       &active_functions,
                                       active_code_marker);
      ActiveFunctionsCollector active_functions_collector(&active_functions,
                                                          active_code_marker);
      isolate_->thread_manager()->IterateArchivedThreads(
          &active_functions_collector);
 
      // Scan the heap for all non-optimized functions which have no
      // debug break slots and are not active or inlined into an active
      // function and mark them for lazy compilation.
      HeapObject* obj = NULL;
      while (((obj = iterator.next()) != NULL)) {
        if (obj->IsJSFunction()) {
          JSFunction* function = JSFunction::cast(obj);
          SharedFunctionInfo* shared = function->shared();
 
          if (!shared->allows_lazy_compilation()) continue;
          if (!shared->script()->IsScript()) continue;
          if (function->IsFromNativeScript()) continue;
          if (shared->code()->gc_metadata() == active_code_marker) continue;
 
          if (shared->is_generator()) {
            generator_functions.Add(Handle<JSFunction>(function, isolate_));
            continue;
          }
 
          Code::Kind kind = function->code()->kind();
          if (kind == Code::FUNCTION &&
              !function->code()->has_debug_break_slots()) {
            function->ReplaceCode(*lazy_compile);
            function->shared()->ReplaceCode(*lazy_compile);
          } else if (kind == Code::BUILTIN &&
              (function->IsInOptimizationQueue() ||
               function->IsMarkedForOptimization() ||
               function->IsMarkedForConcurrentOptimization())) {
            // Abort in-flight compilation.
            Code* shared_code = function->shared()->code();
            if (shared_code->kind() == Code::FUNCTION &&
                shared_code->has_debug_break_slots()) {
              function->ReplaceCode(shared_code);
            } else {
              function->ReplaceCode(*lazy_compile);
              function->shared()->ReplaceCode(*lazy_compile);
            }
          }
        } else if (obj->IsJSGeneratorObject()) {
          JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
          if (!gen->is_suspended()) continue;
 
          JSFunction* fun = gen->function();
          DCHECK_EQ(fun->code()->kind(), Code::FUNCTION);
          if (fun->code()->has_debug_break_slots()) continue;
 
          int pc_offset = gen->continuation();
          DCHECK_LT(0, pc_offset);
 
          int code_offset =
              ComputeCodeOffsetFromPcOffset(fun->code(), pc_offset);
 
          // This will be fixed after we recompile the functions.
          gen->set_continuation(code_offset);
 
          suspended_generators.Add(Handle<JSGeneratorObject>(gen, isolate_));
        }
      }
 
      // Clear gc_metadata field.
      for (int i = 0; i < active_functions.length(); i++) {
        Handle<JSFunction> function = active_functions[i];
        function->shared()->code()->set_gc_metadata(Smi::FromInt(0));
      }
    }
 
    // Recompile generator functions that have suspended activations, and
    // relocate those activations.
    RecompileAndRelocateSuspendedGenerators(suspended_generators);
 
    // Mark generator functions that didn't have suspended activations for lazy
    // recompilation.  Note that this set does not include any active functions.
    for (int i = 0; i < generator_functions.length(); i++) {
      Handle<JSFunction> &function = generator_functions[i];
      if (function->code()->kind() != Code::FUNCTION) continue;
      if (function->code()->has_debug_break_slots()) continue;
      function->ReplaceCode(*lazy_compile);
      function->shared()->ReplaceCode(*lazy_compile);
    }
 
    // Now recompile all functions with activation frames and and
    // patch the return address to run in the new compiled code.  It could be
    // that some active functions were recompiled already by the suspended
    // generator recompilation pass above; a generator with suspended
    // activations could also have active activations.  That's fine.
    for (int i = 0; i < active_functions.length(); i++) {
      Handle<JSFunction> function = active_functions[i];
      Handle<SharedFunctionInfo> shared(function->shared());
 
      // If recompilation is not possible just skip it.
      if (shared->is_toplevel()) continue;
      if (!shared->allows_lazy_compilation()) continue;
      if (shared->code()->kind() == Code::BUILTIN) continue;
 
      EnsureFunctionHasDebugBreakSlots(function);
    }
 
    RedirectActivationsToRecompiledCodeOnThread(isolate_,
                                                isolate_->thread_local_top());
 
    ActiveFunctionsRedirector active_functions_redirector;
    isolate_->thread_manager()->IterateArchivedThreads(
          &active_functions_redirector);
  }
}

References v8::internal::List< T, AllocationPolicy >::Add(), BUILTIN, v8::internal::Isolate::builtins(), v8::internal::JSFunction::code(), v8::internal::CollectActiveFunctionsFromThread(), v8::internal::Heap::CollectAllGarbage(), v8::internal::ComputeCodeOffsetFromPcOffset(), v8::internal::Isolate::concurrent_recompilation_enabled(), v8::internal::JSGeneratorObject::continuation(), DCHECK_EQ, DCHECK_LT, v8::internal::Deoptimizer::DeoptimizeAll(), v8::internal::EnsureFunctionHasDebugBreakSlots(), v8::internal::OptimizingCompilerThread::Flush(), v8::internal::Smi::FromInt(), has_break_points_, v8::internal::Code::has_debug_break_slots(), v8::internal::Isolate::heap(), v8::internal::JSGeneratorObject::is_suspended(), isolate_, v8::internal::ThreadManager::IterateArchivedThreads(), v8::internal::Code::kind(), v8::internal::Heap::kMakeHeapIterableMask, NULL, v8::internal::Isolate::optimizing_compiler_thread(), v8::internal::RecompileAndRelocateSuspendedGenerators(), v8::internal::RedirectActivationsToRecompiledCodeOnThread(), v8::internal::JSGeneratorObject::set_continuation(), v8::internal::Isolate::thread_local_top(), and v8::internal::Isolate::thread_manager().

Referenced by FloodWithOneShot(), IsBreakAtReturn(), PrepareStep(), SetAfterBreakTarget(), SetBreakPoint(), and SetBreakPointForScript().

Here is the call graph for this function:

Here is the caller graph for this function:

PrepareStep()

void v8::internal::Debug::PrepareStep	(	StepAction	step_action,
		int	step_count,
		StackFrame::Id	frame_id
	)

Definition at line 1276 of file debug.cc.

                                               {
  HandleScope scope(isolate_);
 
  PrepareForBreakPoints();
 
  DCHECK(in_debug_scope());
 
  // Remember this step action and count.
  thread_local_.last_step_action_ = step_action;
  if (step_action == StepOut) {
    // For step out target frame will be found on the stack so there is no need
    // to set step counter for it. It's expected to always be 0 for StepOut.
    thread_local_.step_count_ = 0;
  } else {
    thread_local_.step_count_ = step_count;
  }
 
  // Get the frame where the execution has stopped and skip the debug frame if
  // any. The debug frame will only be present if execution was stopped due to
  // hitting a break point. In other situations (e.g. unhandled exception) the
  // debug frame is not present.
  StackFrame::Id id = break_frame_id();
  if (id == StackFrame::NO_ID) {
    // If there is no JavaScript stack don't do anything.
    return;
  }
  if (frame_id != StackFrame::NO_ID) {
    id = frame_id;
  }
  JavaScriptFrameIterator frames_it(isolate_, id);
  JavaScriptFrame* frame = frames_it.frame();
 
  // First of all ensure there is one-shot break points in the top handler
  // if any.
  FloodHandlerWithOneShot();
 
  // If the function on the top frame is unresolved perform step out. This will
  // be the case when calling unknown functions and having the debugger stopped
  // in an unhandled exception.
  if (!frame->function()->IsJSFunction()) {
    // Step out: Find the calling JavaScript frame and flood it with
    // breakpoints.
    frames_it.Advance();
    // Fill the function to return to with one-shot break points.
    JSFunction* function = frames_it.frame()->function();
    FloodWithOneShot(Handle<JSFunction>(function));
    return;
  }
 
  // Get the debug info (create it if it does not exist).
  Handle<JSFunction> function(frame->function());
  Handle<SharedFunctionInfo> shared(function->shared());
  if (!EnsureDebugInfo(shared, function)) {
    // Return if ensuring debug info failed.
    return;
  }
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
 
  // Find the break location where execution has stopped.
  BreakLocationIterator it(debug_info, ALL_BREAK_LOCATIONS);
  // pc points to the instruction after the current one, possibly a break
  // location as well. So the "- 1" to exclude it from the search.
  it.FindBreakLocationFromAddress(frame->pc() - 1);
 
  // Compute whether or not the target is a call target.
  bool is_load_or_store = false;
  bool is_inline_cache_stub = false;
  bool is_at_restarted_function = false;
  Handle<Code> call_function_stub;
 
  if (thread_local_.restarter_frame_function_pointer_ == NULL) {
    if (RelocInfo::IsCodeTarget(it.rinfo()->rmode())) {
      bool is_call_target = false;
      Address target = it.rinfo()->target_address();
      Code* code = Code::GetCodeFromTargetAddress(target);
      if (code->is_call_stub()) {
        is_call_target = true;
      }
      if (code->is_inline_cache_stub()) {
        is_inline_cache_stub = true;
        is_load_or_store = !is_call_target;
      }
 
      // Check if target code is CallFunction stub.
      Code* maybe_call_function_stub = code;
      // If there is a breakpoint at this line look at the original code to
      // check if it is a CallFunction stub.
      if (it.IsDebugBreak()) {
        Address original_target = it.original_rinfo()->target_address();
        maybe_call_function_stub =
            Code::GetCodeFromTargetAddress(original_target);
      }
      if ((maybe_call_function_stub->kind() == Code::STUB &&
           CodeStub::GetMajorKey(maybe_call_function_stub) ==
               CodeStub::CallFunction) ||
          maybe_call_function_stub->kind() == Code::CALL_IC) {
        // Save reference to the code as we may need it to find out arguments
        // count for 'step in' later.
        call_function_stub = Handle<Code>(maybe_call_function_stub);
      }
    }
  } else {
    is_at_restarted_function = true;
  }
 
  // If this is the last break code target step out is the only possibility.
  if (it.IsExit() || step_action == StepOut) {
    if (step_action == StepOut) {
      // Skip step_count frames starting with the current one.
      while (step_count-- > 0 && !frames_it.done()) {
        frames_it.Advance();
      }
    } else {
      DCHECK(it.IsExit());
      frames_it.Advance();
    }
    // Skip builtin functions on the stack.
    while (!frames_it.done() &&
           frames_it.frame()->function()->IsFromNativeScript()) {
      frames_it.Advance();
    }
    // Step out: If there is a JavaScript caller frame, we need to
    // flood it with breakpoints.
    if (!frames_it.done()) {
      // Fill the function to return to with one-shot break points.
      JSFunction* function = frames_it.frame()->function();
      FloodWithOneShot(Handle<JSFunction>(function));
      // Set target frame pointer.
      ActivateStepOut(frames_it.frame());
    }
  } else if (!(is_inline_cache_stub || RelocInfo::IsConstructCall(it.rmode()) ||
               !call_function_stub.is_null() || is_at_restarted_function)
             || step_action == StepNext || step_action == StepMin) {
    // Step next or step min.
 
    // Fill the current function with one-shot break points.
    FloodWithOneShot(function);
 
    // Remember source position and frame to handle step next.
    thread_local_.last_statement_position_ =
        debug_info->code()->SourceStatementPosition(frame->pc());
    thread_local_.last_fp_ = frame->UnpaddedFP();
  } else {
    // If there's restarter frame on top of the stack, just get the pointer
    // to function which is going to be restarted.
    if (is_at_restarted_function) {
      Handle<JSFunction> restarted_function(
          JSFunction::cast(*thread_local_.restarter_frame_function_pointer_));
      FloodWithOneShot(restarted_function);
    } else if (!call_function_stub.is_null()) {
      // If it's CallFunction stub ensure target function is compiled and flood
      // it with one shot breakpoints.
      bool is_call_ic = call_function_stub->kind() == Code::CALL_IC;
 
      // Find out number of arguments from the stub minor key.
      uint32_t key = call_function_stub->stub_key();
      // Argc in the stub is the number of arguments passed - not the
      // expected arguments of the called function.
      int call_function_arg_count = is_call_ic
          ? CallICStub::ExtractArgcFromMinorKey(CodeStub::MinorKeyFromKey(key))
          : CallFunctionStub::ExtractArgcFromMinorKey(
              CodeStub::MinorKeyFromKey(key));
 
      DCHECK(is_call_ic ||
             CodeStub::GetMajorKey(*call_function_stub) ==
                 CodeStub::MajorKeyFromKey(key));
 
      // Find target function on the expression stack.
      // Expression stack looks like this (top to bottom):
      // argN
      // ...
      // arg0
      // Receiver
      // Function to call
      int expressions_count = frame->ComputeExpressionsCount();
      DCHECK(expressions_count - 2 - call_function_arg_count >= 0);
      Object* fun = frame->GetExpression(
          expressions_count - 2 - call_function_arg_count);
 
      // Flood the actual target of call/apply.
      if (fun->IsJSFunction()) {
        Isolate* isolate = JSFunction::cast(fun)->GetIsolate();
        Code* apply = isolate->builtins()->builtin(Builtins::kFunctionApply);
        Code* call = isolate->builtins()->builtin(Builtins::kFunctionCall);
        while (fun->IsJSFunction()) {
          Code* code = JSFunction::cast(fun)->shared()->code();
          if (code != apply && code != call) break;
          fun = frame->GetExpression(
              expressions_count - 1 - call_function_arg_count);
        }
      }
 
      if (fun->IsJSFunction()) {
        Handle<JSFunction> js_function(JSFunction::cast(fun));
        if (js_function->shared()->bound()) {
          Debug::FloodBoundFunctionWithOneShot(js_function);
        } else if (!js_function->IsFromNativeScript()) {
          // Don't step into builtins.
          // It will also compile target function if it's not compiled yet.
          FloodWithOneShot(js_function);
        }
      }
    }
 
    // Fill the current function with one-shot break points even for step in on
    // a call target as the function called might be a native function for
    // which step in will not stop. It also prepares for stepping in
    // getters/setters.
    FloodWithOneShot(function);
 
    if (is_load_or_store) {
      // Remember source position and frame to handle step in getter/setter. If
      // there is a custom getter/setter it will be handled in
      // Object::Get/SetPropertyWithAccessor, otherwise the step action will be
      // propagated on the next Debug::Break.
      thread_local_.last_statement_position_ =
          debug_info->code()->SourceStatementPosition(frame->pc());
      thread_local_.last_fp_ = frame->UnpaddedFP();
    }
 
    // Step in or Step in min
    it.PrepareStepIn(isolate_);
    ActivateStepIn(frame);
  }
}

References ActivateStepIn(), ActivateStepOut(), v8::internal::ALL_BREAK_LOCATIONS, break_frame_id(), v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), v8::internal::StandardFrame::ComputeExpressionsCount(), DCHECK, EnsureDebugInfo(), v8::internal::CallICStub::ExtractArgcFromMinorKey(), v8::internal::CallFunctionStub::ExtractArgcFromMinorKey(), v8::internal::BreakLocationIterator::FindBreakLocationFromAddress(), FloodBoundFunctionWithOneShot(), FloodHandlerWithOneShot(), FloodWithOneShot(), v8::internal::JavaScriptFrame::function(), v8::internal::Code::GetCodeFromTargetAddress(), GetDebugInfo(), v8::internal::StandardFrame::GetExpression(), in_debug_scope(), v8::internal::Code::is_call_stub(), v8::internal::Code::is_inline_cache_stub(), v8::internal::Handle< T >::is_null(), v8::internal::RelocInfo::IsCodeTarget(), v8::internal::RelocInfo::IsConstructCall(), v8::internal::BreakLocationIterator::IsDebugBreak(), v8::internal::BreakLocationIterator::IsExit(), isolate_, v8::internal::Code::kind(), v8::internal::Debug::ThreadLocal::last_fp_, v8::internal::Debug::ThreadLocal::last_statement_position_, v8::internal::Debug::ThreadLocal::last_step_action_, NULL, v8::internal::BreakLocationIterator::original_rinfo(), PrepareForBreakPoints(), v8::internal::BreakLocationIterator::PrepareStepIn(), v8::internal::Debug::ThreadLocal::restarter_frame_function_pointer_, v8::internal::BreakLocationIterator::rinfo(), v8::internal::RelocInfo::rmode(), v8::internal::BreakLocationIterator::rmode(), v8::internal::Debug::ThreadLocal::step_count_, v8::internal::StepMin, v8::internal::StepNext, v8::internal::StepOut, v8::internal::STUB, and thread_local_.

Referenced by Break().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessDebugEvent()

void v8::internal::Debug::ProcessDebugEvent ( v8::DebugEvent  event, Handle< JSObject >  event_data, bool  auto_continue  )

private

Definition at line 2709 of file debug.cc.

                                                  {
  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;
 
  // First notify the message handler if any.
  if (message_handler_ != NULL) {
    NotifyMessageHandler(event,
                         Handle<JSObject>::cast(exec_state),
                         event_data,
                         auto_continue);
  }
  // Notify registered debug event listener. This can be either a C or
  // a JavaScript function. Don't call event listener for v8::Break
  // here, if it's only a debug command -- they will be processed later.
  if ((event != v8::Break || !auto_continue) && !event_listener_.is_null()) {
    CallEventCallback(event, exec_state, event_data, NULL);
  }
  // Process pending debug commands.
  if (event == v8::Break) {
    while (!event_command_queue_.IsEmpty()) {
      CommandMessage command = event_command_queue_.Get();
      if (!event_listener_.is_null()) {
        CallEventCallback(v8::BreakForCommand,
                          exec_state,
                          event_data,
                          command.client_data());
      }
      command.Dispose();
    }
  }
}

References v8::Break, v8::BreakForCommand, CallEventCallback(), v8::internal::CommandMessage::client_data(), v8::internal::CommandMessage::Dispose(), event_command_queue_, event_listener_, isolate_, MakeExecutionState(), message_handler_, NotifyMessageHandler(), and NULL.

Referenced by OnAfterCompile(), OnAsyncTaskEvent(), OnBeforeCompile(), OnCompileError(), OnDebugBreak(), OnException(), and OnPromiseEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessDebugMessages()

void v8::internal::Debug::ProcessDebugMessages

(

bool

debug_command_only

)

Definition at line 3057 of file debug.cc.

                                                        {
  isolate_->stack_guard()->ClearDebugCommand();
 
  StackLimitCheck check(isolate_);
  if (check.HasOverflowed()) return;
 
  HandleScope scope(isolate_);
  DebugScope debug_scope(this);
  if (debug_scope.failed()) return;
 
  // Notify the debug event listeners. Indicate auto continue if the break was
  // a debug command break.
  OnDebugBreak(isolate_->factory()->undefined_value(), debug_command_only);
}

References DebugScope, v8::internal::Isolate::factory(), isolate_, OnDebugBreak(), and v8::internal::Isolate::stack_guard().

Referenced by HandleDebugBreak().

Here is the call graph for this function:

Here is the caller graph for this function:

PromiseHasRejectHandler()

bool v8::internal::Debug::PromiseHasRejectHandler ( Handle< JSObject >  promise )

private

Definition at line 1265 of file debug.cc.

                                                            {
  Handle<JSFunction> fun = Handle<JSFunction>::cast(
      JSObject::GetDataProperty(isolate_->js_builtins_object(),
                                isolate_->factory()->NewStringFromStaticChars(
                                    "PromiseHasRejectHandler")));
  Handle<Object> result =
      Execution::Call(isolate_, fun, promise, 0, NULL).ToHandleChecked();
  return result->IsTrue();
}

References v8::internal::Handle< T >::cast(), v8::internal::Isolate::factory(), v8::internal::JSObject::GetDataProperty(), isolate_, v8::internal::Isolate::js_builtins_object(), and NULL.

Referenced by OnException().

Here is the call graph for this function:

Here is the caller graph for this function:

RecordEvalCaller()

void v8::internal::Debug::RecordEvalCaller ( Handle< Script >  script )

static

Definition at line 2419 of file debug.cc.

                                                  {
  script->set_compilation_type(Script::COMPILATION_TYPE_EVAL);
  // For eval scripts add information on the function from which eval was
  // called.
  StackTraceFrameIterator it(script->GetIsolate());
  if (!it.done()) {
    script->set_eval_from_shared(it.frame()->function()->shared());
    Code* code = it.frame()->LookupCode();
    int offset = static_cast<int>(
        it.frame()->pc() - code->instruction_start());
    script->set_eval_from_instructions_offset(Smi::FromInt(offset));
  }
}

References v8::internal::Script::COMPILATION_TYPE_EVAL, v8::internal::Smi::FromInt(), and v8::internal::Code::instruction_start().

Referenced by v8::internal::Compiler::GetFunctionFromEval().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveDebugInfo()

void v8::internal::Debug::RemoveDebugInfo ( Handle< DebugInfo >  debug_info )

private

Definition at line 2208 of file debug.cc.

                                                        {
  DCHECK(debug_info_list_ != NULL);
  // Run through the debug info objects to find this one and remove it.
  DebugInfoListNode* prev = NULL;
  DebugInfoListNode* current = debug_info_list_;
  while (current != NULL) {
    if (*current->debug_info() == *debug_info) {
      // Unlink from list. If prev is NULL we are looking at the first element.
      if (prev == NULL) {
        debug_info_list_ = current->next();
      } else {
        prev->set_next(current->next());
      }
      current->debug_info()->shared()->set_debug_info(
              isolate_->heap()->undefined_value());
      delete current;
 
      // If there are no more debug info objects there are not more break
      // points.
      has_break_points_ = debug_info_list_ != NULL;
 
      return;
    }
    // Move to next in list.
    prev = current;
    current = current->next();
  }
  UNREACHABLE();
}

References DCHECK, v8::internal::DebugInfoListNode::debug_info(), debug_info_list_, has_break_points_, v8::internal::Isolate::heap(), isolate_, v8::internal::DebugInfoListNode::next(), NULL, v8::internal::DebugInfoListNode::set_next(), and UNREACHABLE.

Referenced by ClearAllBreakPoints(), ClearBreakPoint(), and HandleWeakDebugInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

restarter_frame_function_pointer_address()

Address v8::internal::Debug::restarter_frame_function_pointer_address ( )

inline

Definition at line 485 of file debug.h.

                                                     {
    Object*** address = &thread_local_.restarter_frame_function_pointer_;
    return reinterpret_cast<Address>(address);
  }

References v8::internal::Debug::ThreadLocal::restarter_frame_function_pointer_, and thread_local_.

RestoreDebug()

char * v8::internal::Debug::RestoreDebug

(

char *

from

)

Definition at line 579 of file debug.cc.

                                       {
  char* from = storage;
  MemCopy(reinterpret_cast<char*>(&thread_local_), from, sizeof(ThreadLocal));
  return storage + ArchiveSpacePerThread();
}

References ArchiveSpacePerThread(), v8::internal::MemCopy(), and thread_local_.

Referenced by v8::internal::ThreadManager::RestoreThread().

Here is the call graph for this function:

Here is the caller graph for this function:

set_disable_break()

void v8::internal::Debug::set_disable_break ( bool  v )

inline

Definition at line 471 of file debug.h.

{ break_disabled_ = v; }

References break_disabled_.

set_live_edit_enabled()

void v8::internal::Debug::set_live_edit_enabled ( bool  v )

inline

Definition at line 460 of file debug.h.

{ live_edit_enabled_ = v; }

References live_edit_enabled_.

Referenced by v8::Debug::SetLiveEditEnabled().

Here is the caller graph for this function:

SetAfterBreakTarget()

void v8::internal::Debug::SetAfterBreakTarget

(

JavaScriptFrame *

frame

)

Definition at line 2239 of file debug.cc.

                                                      {
  after_break_target_ = NULL;
 
  if (LiveEdit::SetAfterBreakTarget(this)) return;  // LiveEdit did the job.
 
  HandleScope scope(isolate_);
  PrepareForBreakPoints();
 
  // Get the executing function in which the debug break occurred.
  Handle<JSFunction> function(JSFunction::cast(frame->function()));
  Handle<SharedFunctionInfo> shared(function->shared());
  if (!EnsureDebugInfo(shared, function)) {
    // Return if we failed to retrieve the debug info.
    return;
  }
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
  Handle<Code> code(debug_info->code());
  Handle<Code> original_code(debug_info->original_code());
#ifdef DEBUG
  // Get the code which is actually executing.
  Handle<Code> frame_code(frame->LookupCode());
  DCHECK(frame_code.is_identical_to(code));
#endif
 
  // Find the call address in the running code. This address holds the call to
  // either a DebugBreakXXX or to the debug break return entry code if the
  // break point is still active after processing the break point.
  Address addr = Assembler::break_address_from_return_address(frame->pc());
 
  // Check if the location is at JS exit or debug break slot.
  bool at_js_return = false;
  bool break_at_js_return_active = false;
  bool at_debug_break_slot = false;
  RelocIterator it(debug_info->code());
  while (!it.done() && !at_js_return && !at_debug_break_slot) {
    if (RelocInfo::IsJSReturn(it.rinfo()->rmode())) {
      at_js_return = (it.rinfo()->pc() ==
          addr - Assembler::kPatchReturnSequenceAddressOffset);
      break_at_js_return_active = it.rinfo()->IsPatchedReturnSequence();
    }
    if (RelocInfo::IsDebugBreakSlot(it.rinfo()->rmode())) {
      at_debug_break_slot = (it.rinfo()->pc() ==
          addr - Assembler::kPatchDebugBreakSlotAddressOffset);
    }
    it.next();
  }
 
  // Handle the jump to continue execution after break point depending on the
  // break location.
  if (at_js_return) {
    // If the break point as return is still active jump to the corresponding
    // place in the original code. If not the break point was removed during
    // break point processing.
    if (break_at_js_return_active) {
      addr += original_code->instruction_start() - code->instruction_start();
    }
 
    // Move back to where the call instruction sequence started.
    after_break_target_ = addr - Assembler::kPatchReturnSequenceAddressOffset;
  } else if (at_debug_break_slot) {
    // Address of where the debug break slot starts.
    addr = addr - Assembler::kPatchDebugBreakSlotAddressOffset;
 
    // Continue just after the slot.
    after_break_target_ = addr + Assembler::kDebugBreakSlotLength;
  } else {
    addr = Assembler::target_address_from_return_address(frame->pc());
    if (IsDebugBreak(Assembler::target_address_at(addr, *code))) {
      // We now know that there is still a debug break call at the target
      // address, so the break point is still there and the original code will
      // hold the address to jump to in order to complete the call which is
      // replaced by a call to DebugBreakXXX.
 
      // Find the corresponding address in the original code.
      addr += original_code->instruction_start() - code->instruction_start();
 
      // Install jump to the call address in the original code. This will be the
      // call which was overwritten by the call to DebugBreakXXX.
      after_break_target_ = Assembler::target_address_at(addr, *original_code);
    } else {
      // There is no longer a break point present. Don't try to look in the
      // original code as the running code will have the right address. This
      // takes care of the case where the last break point is removed from the
      // function and therefore no "original code" is available.
      after_break_target_ = Assembler::target_address_at(addr, *code);
    }
  }
}

References after_break_target_, v8::internal::Assembler::break_address_from_return_address(), DCHECK, v8::internal::RelocIterator::done(), EnsureDebugInfo(), v8::internal::JavaScriptFrame::function(), GetDebugInfo(), IsDebugBreak(), v8::internal::RelocInfo::IsDebugBreakSlot(), v8::internal::RelocInfo::IsJSReturn(), isolate_, v8::internal::Assembler::kDebugBreakSlotLength, v8::internal::Assembler::kPatchDebugBreakSlotAddressOffset, v8::internal::Assembler::kPatchReturnSequenceAddressOffset, v8::internal::RelocIterator::next(), NULL, v8::internal::RelocInfo::pc(), PrepareForBreakPoints(), v8::internal::RelocIterator::rinfo(), v8::internal::RelocInfo::rmode(), v8::internal::LiveEdit::SetAfterBreakTarget(), v8::internal::Assembler::target_address_at(), and v8::internal::Assembler::target_address_from_return_address().

Here is the call graph for this function:

SetBreakPoint()

bool v8::internal::Debug::SetBreakPoint	(	Handle< JSFunction >	function,
		Handle< Object >	break_point_object,
		int *	source_position
	)

Definition at line 1075 of file debug.cc.

                                                {
  HandleScope scope(isolate_);
 
  PrepareForBreakPoints();
 
  // Make sure the function is compiled and has set up the debug info.
  Handle<SharedFunctionInfo> shared(function->shared());
  if (!EnsureDebugInfo(shared, function)) {
    // Return if retrieving debug info failed.
    return true;
  }
 
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
  // Source positions starts with zero.
  DCHECK(*source_position >= 0);
 
  // Find the break point and change it.
  BreakLocationIterator it(debug_info, SOURCE_BREAK_LOCATIONS);
  it.FindBreakLocationFromPosition(*source_position, STATEMENT_ALIGNED);
  it.SetBreakPoint(break_point_object);
 
  *source_position = it.position();
 
  // At least one active break point now.
  return debug_info->GetBreakPointCount() > 0;
}

References DCHECK, EnsureDebugInfo(), v8::internal::BreakLocationIterator::FindBreakLocationFromPosition(), GetDebugInfo(), isolate_, v8::internal::BreakLocationIterator::position(), PrepareForBreakPoints(), v8::internal::BreakLocationIterator::SetBreakPoint(), v8::internal::SOURCE_BREAK_LOCATIONS, and v8::internal::STATEMENT_ALIGNED.

Here is the call graph for this function:

SetBreakPointForScript()

bool v8::internal::Debug::SetBreakPointForScript	(	Handle< Script >	script,
		Handle< Object >	break_point_object,
		int *	source_position,
		BreakPositionAlignment	alignment
	)

Definition at line 1105 of file debug.cc.

                                                                     {
  HandleScope scope(isolate_);
 
  PrepareForBreakPoints();
 
  // Obtain shared function info for the function.
  Object* result = FindSharedFunctionInfoInScript(script, *source_position);
  if (result->IsUndefined()) return false;
 
  // Make sure the function has set up the debug info.
  Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(result));
  if (!EnsureDebugInfo(shared, Handle<JSFunction>::null())) {
    // Return if retrieving debug info failed.
    return false;
  }
 
  // Find position within function. The script position might be before the
  // source position of the first function.
  int position;
  if (shared->start_position() > *source_position) {
    position = 0;
  } else {
    position = *source_position - shared->start_position();
  }
 
  Handle<DebugInfo> debug_info = GetDebugInfo(shared);
  // Source positions starts with zero.
  DCHECK(position >= 0);
 
  // Find the break point and change it.
  BreakLocationIterator it(debug_info, SOURCE_BREAK_LOCATIONS);
  it.FindBreakLocationFromPosition(position, alignment);
  it.SetBreakPoint(break_point_object);
 
  *source_position = it.position() + shared->start_position();
 
  // At least one active break point now.
  DCHECK(debug_info->GetBreakPointCount() > 0);
  return true;
}

References DCHECK, EnsureDebugInfo(), v8::internal::BreakLocationIterator::FindBreakLocationFromPosition(), FindSharedFunctionInfoInScript(), GetDebugInfo(), isolate_, v8::internal::BreakLocationIterator::position(), PrepareForBreakPoints(), v8::internal::BreakLocationIterator::SetBreakPoint(), and v8::internal::SOURCE_BREAK_LOCATIONS.

Here is the call graph for this function:

SetEventListener()

void v8::internal::Debug::SetEventListener	(	Handle< Object >	callback,
		Handle< Object >	data
	)

Definition at line 2921 of file debug.cc.

                                                  {
  GlobalHandles* global_handles = isolate_->global_handles();
 
  // Remove existing entry.
  GlobalHandles::Destroy(event_listener_.location());
  event_listener_ = Handle<Object>();
  GlobalHandles::Destroy(event_listener_data_.location());
  event_listener_data_ = Handle<Object>();
 
  // Set new entry.
  if (!callback->IsUndefined() && !callback->IsNull()) {
    event_listener_ = global_handles->Create(*callback);
    if (data.is_null()) data = isolate_->factory()->undefined_value();
    event_listener_data_ = global_handles->Create(*data);
  }
 
  UpdateState();
}

References v8::internal::GlobalHandles::Create(), v8::internal::GlobalHandles::Destroy(), event_listener_, event_listener_data_, v8::internal::Isolate::factory(), v8::internal::Isolate::global_handles(), v8::internal::Handle< T >::is_null(), isolate_, and UpdateState().

Referenced by v8::Debug::SetDebugEventListener().

Here is the call graph for this function:

Here is the caller graph for this function:

SetMessageHandler()

void v8::internal::Debug::SetMessageHandler

(

v8::Debug::MessageHandler

handler

)

Definition at line 2942 of file debug.cc.

                                                           {
  message_handler_ = handler;
  UpdateState();
  if (handler == NULL && in_debug_scope()) {
    // Send an empty command to the debugger if in a break to make JavaScript
    // run again if the debugger is closed.
    EnqueueCommandMessage(Vector<const uint16_t>::empty());
  }
}

References EnqueueCommandMessage(), in_debug_scope(), message_handler_, NULL, and UpdateState().

Referenced by v8::Debug::SetMessageHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

SetNextBreakId()

void v8::internal::Debug::SetNextBreakId ( )

inlineprivate

Definition at line 499 of file debug.h.

                        {
    thread_local_.break_id_ = ++thread_local_.break_count_;
  }

References v8::internal::Debug::ThreadLocal::break_count_, v8::internal::Debug::ThreadLocal::break_id_, and thread_local_.

step_in_fp_addr()

Address v8::internal::Debug::step_in_fp_addr ( )

inline

Definition at line 490 of file debug.h.

                            {
    return reinterpret_cast<Address>(&thread_local_.step_into_fp_);
  }

References v8::internal::Debug::ThreadLocal::step_into_fp_, and thread_local_.

StepInActive()

bool v8::internal::Debug::StepInActive ( )

inline

Definition at line 402 of file debug.h.

{ return thread_local_.step_into_fp_ != 0; }

References v8::internal::Debug::ThreadLocal::step_into_fp_, and thread_local_.

Referenced by ActivateStepOut(), v8::internal::Object::GetPropertyWithDefinedGetter(), v8::internal::Runtime_NewObjectHelper(), and v8::internal::Object::SetPropertyWithDefinedSetter().

Here is the caller graph for this function:

StepNextContinue()

bool v8::internal::Debug::StepNextContinue	(	BreakLocationIterator *	break_location_iterator,
		JavaScriptFrame *	frame
	)

Definition at line 1511 of file debug.cc.

                                                     {
  // StepNext and StepOut shouldn't bring us deeper in code, so last frame
  // shouldn't be a parent of current frame.
  if (thread_local_.last_step_action_ == StepNext ||
      thread_local_.last_step_action_ == StepOut) {
    if (frame->fp() < thread_local_.last_fp_) return true;
  }
 
  // If the step last action was step next or step in make sure that a new
  // statement is hit.
  if (thread_local_.last_step_action_ == StepNext ||
      thread_local_.last_step_action_ == StepIn) {
    // Never continue if returning from function.
    if (break_location_iterator->IsExit()) return false;
 
    // Continue if we are still on the same frame and in the same statement.
    int current_statement_position =
        break_location_iterator->code()->SourceStatementPosition(frame->pc());
    return thread_local_.last_fp_ == frame->UnpaddedFP() &&
        thread_local_.last_statement_position_ == current_statement_position;
  }
 
  // No step next action - don't continue.
  return false;
}

References v8::internal::BreakLocationIterator::code(), v8::internal::BreakLocationIterator::IsExit(), v8::internal::Debug::ThreadLocal::last_fp_, v8::internal::Debug::ThreadLocal::last_statement_position_, v8::internal::Debug::ThreadLocal::last_step_action_, v8::internal::Code::SourceStatementPosition(), v8::internal::StepIn, v8::internal::StepNext, v8::internal::StepOut, and thread_local_.

Referenced by Break().

Here is the call graph for this function:

Here is the caller graph for this function:

StepOutActive()

bool v8::internal::Debug::StepOutActive ( )

inline

Definition at line 407 of file debug.h.

{ return thread_local_.step_out_fp_ != 0; }

References v8::internal::Debug::ThreadLocal::step_out_fp_, and thread_local_.

Referenced by ActivateStepIn(), and Break().

Here is the caller graph for this function:

ThreadInit()

void v8::internal::Debug::ThreadInit ( )

private

Definition at line 554 of file debug.cc.

                       {
  thread_local_.break_count_ = 0;
  thread_local_.break_id_ = 0;
  thread_local_.break_frame_id_ = StackFrame::NO_ID;
  thread_local_.last_step_action_ = StepNone;
  thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
  thread_local_.step_count_ = 0;
  thread_local_.last_fp_ = 0;
  thread_local_.queued_step_count_ = 0;
  thread_local_.step_into_fp_ = 0;
  thread_local_.step_out_fp_ = 0;
  // TODO(isolates): frames_are_dropped_?
  thread_local_.current_debug_scope_ = NULL;
  thread_local_.restarter_frame_function_pointer_ = NULL;
}

References v8::internal::Debug::ThreadLocal::break_count_, v8::internal::Debug::ThreadLocal::break_frame_id_, v8::internal::Debug::ThreadLocal::break_id_, v8::internal::Debug::ThreadLocal::current_debug_scope_, v8::internal::RelocInfo::kNoPosition, v8::internal::Debug::ThreadLocal::last_fp_, v8::internal::Debug::ThreadLocal::last_statement_position_, v8::internal::Debug::ThreadLocal::last_step_action_, NULL, v8::internal::Debug::ThreadLocal::queued_step_count_, v8::internal::Debug::ThreadLocal::restarter_frame_function_pointer_, v8::internal::Debug::ThreadLocal::step_count_, v8::internal::Debug::ThreadLocal::step_into_fp_, v8::internal::Debug::ThreadLocal::step_out_fp_, v8::internal::StepNone, and thread_local_.

Referenced by ArchiveDebug(), and Debug().

Here is the caller graph for this function:

Unload()

void v8::internal::Debug::Unload ( )

private

Definition at line 847 of file debug.cc.

                   {
  ClearAllBreakPoints();
  ClearStepping();
 
  // Return debugger is not loaded.
  if (!is_loaded()) return;
 
  // Clear the script cache.
  if (script_cache_ != NULL) {
    delete script_cache_;
    script_cache_ = NULL;
  }
 
  // Clear debugger context global handle.
  GlobalHandles::Destroy(Handle<Object>::cast(debug_context_).location());
  debug_context_ = Handle<Context>();
}

References ClearAllBreakPoints(), ClearStepping(), debug_context_, v8::internal::GlobalHandles::Destroy(), is_loaded(), NULL, and script_cache_.

Referenced by v8::internal::Isolate::Deinit(), and UpdateState().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateState()

void v8::internal::Debug::UpdateState ( )

private

Definition at line 2954 of file debug.cc.

                        {
  is_active_ = message_handler_ != NULL || !event_listener_.is_null();
  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();
  }
}

References v8::internal::Isolate::compilation_cache(), v8::internal::CompilationCache::Disable(), v8::internal::CompilationCache::Enable(), event_listener_, in_debug_scope(), is_active_, is_loaded(), isolate_, Load(), message_handler_, NULL, and Unload().

Referenced by SetEventListener(), and SetMessageHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

CheckDebuggerUnloaded

void CheckDebuggerUnloaded ( bool  check_functions )

friend

DebugScope

friend class DebugScope

friend

Definition at line 647 of file debug.h.

Referenced by Break(), Call(), GetDebugContext(), OnAfterCompile(), OnAsyncTaskEvent(), OnBeforeCompile(), OnCompileError(), OnException(), OnPromiseEvent(), and ProcessDebugMessages().

DisableBreak

friend class DisableBreak

friend

Definition at line 648 of file debug.h.

Referenced by Load().

GetDebuggedFunctions

Handle<FixedArray> GetDebuggedFunctions ( )

friend

Isolate

friend class Isolate

friend

Definition at line 646 of file debug.h.

LiveEdit

friend class LiveEdit

friend

Definition at line 649 of file debug.h.

SuppressDebug

friend class SuppressDebug

friend

Definition at line 650 of file debug.h.

Referenced by Load().

Member Data Documentation

after_break_target_

Address v8::internal::Debug::after_break_target_

private

Definition at line 592 of file debug.h.

Referenced by after_break_target_address(), v8::internal::LiveEdit::SetAfterBreakTarget(), and SetAfterBreakTarget().

break_disabled_

bool v8::internal::Debug::break_disabled_

private

Definition at line 582 of file debug.h.

Referenced by Break(), HandleDebugBreak(), and set_disable_break().

break_on_exception_

bool v8::internal::Debug::break_on_exception_

private

Definition at line 583 of file debug.h.

Referenced by ChangeBreakOnException(), IsBreakOnException(), and OnException().

break_on_uncaught_exception_

bool v8::internal::Debug::break_on_uncaught_exception_

private

Definition at line 584 of file debug.h.

Referenced by ChangeBreakOnException(), IsBreakOnException(), and OnException().

command_queue_

LockingCommandMessageQueue v8::internal::Debug::command_queue_

private

Definition at line 575 of file debug.h.

Referenced by EnqueueCommandMessage(), has_commands(), and NotifyMessageHandler().

command_received_

base::Semaphore v8::internal::Debug::command_received_

private

Definition at line 574 of file debug.h.

Referenced by EnqueueCommandMessage(), and NotifyMessageHandler().

debug_context_

Handle<Context> v8::internal::Debug::debug_context_

private

Definition at line 567 of file debug.h.

Referenced by debug_context(), is_loaded(), Load(), and Unload().

debug_info_list_

DebugInfoListNode* v8::internal::Debug::debug_info_list_

private

Definition at line 587 of file debug.h.

Referenced by ClearAllBreakPoints(), ClearBreakPoint(), ClearOneShot(), EnsureDebugInfo(), HandleWeakDebugInfo(), and RemoveDebugInfo().

event_command_queue_

LockingCommandMessageQueue v8::internal::Debug::event_command_queue_

private

Definition at line 576 of file debug.h.

Referenced by EnqueueDebugCommand(), and ProcessDebugEvent().

event_listener_

Handle<Object> v8::internal::Debug::event_listener_

private

Definition at line 568 of file debug.h.

Referenced by CallEventCallback(), ProcessDebugEvent(), SetEventListener(), and UpdateState().

event_listener_data_

Handle<Object> v8::internal::Debug::event_listener_data_

private

Definition at line 569 of file debug.h.

Referenced by CallEventCallback(), and SetEventListener().

has_break_points_

bool v8::internal::Debug::has_break_points_

private

Definition at line 581 of file debug.h.

Referenced by EnsureDebugInfo(), FindSharedFunctionInfoInScript(), has_break_points(), IsBreakAtReturn(), PrepareForBreakPoints(), and RemoveDebugInfo().

is_active_

bool v8::internal::Debug::is_active_

private

Definition at line 578 of file debug.h.

Referenced by ignore_events(), is_active(), is_active_address(), NotifyMessageHandler(), and UpdateState().

is_suppressed_

bool v8::internal::Debug::is_suppressed_

private

Definition at line 579 of file debug.h.

Referenced by ignore_events(), and Load().

isolate_

Isolate* v8::internal::Debug::isolate_

private

Definition at line 644 of file debug.h.

Referenced by AssertDebugContext(), Break(), Call(), CallEventCallback(), CheckBreakPoint(), CheckBreakPoints(), ClearBreakPoint(), ClearMirrorCache(), EnqueueCommandMessage(), EnqueueDebugCommand(), FindSharedFunctionInfoInScript(), FloodBoundFunctionWithOneShot(), FloodHandlerWithOneShot(), GetDebugContext(), GetLoadedScripts(), HandleDebugBreak(), IsBreakAtReturn(), Load(), MakeBreakEvent(), MakeCompileEvent(), MakeExceptionEvent(), MakeExecutionState(), MakeJSObject(), NotifyMessageHandler(), OnAfterCompile(), OnAsyncTaskEvent(), OnBeforeCompile(), OnCompileError(), OnDebugBreak(), OnPromiseEvent(), OnPromiseReject(), OnThrow(), PrepareForBreakPoints(), PrepareStep(), ProcessDebugEvent(), ProcessDebugMessages(), PromiseHasRejectHandler(), RemoveDebugInfo(), v8::internal::LiveEdit::SetAfterBreakTarget(), SetAfterBreakTarget(), SetBreakPoint(), SetBreakPointForScript(), SetEventListener(), and UpdateState().

kQueueInitialSize

const int v8::internal::Debug::kQueueInitialSize = 4

staticprivate

Definition at line 573 of file debug.h.

live_edit_enabled_

bool v8::internal::Debug::live_edit_enabled_

private

Definition at line 580 of file debug.h.

Referenced by live_edit_enabled(), and set_live_edit_enabled().

message_handler_

v8::Debug::MessageHandler v8::internal::Debug::message_handler_

private

Definition at line 571 of file debug.h.

Referenced by InvokeMessageHandler(), ProcessDebugEvent(), SetMessageHandler(), and UpdateState().

script_cache_

ScriptCache* v8::internal::Debug::script_cache_

private

Definition at line 586 of file debug.h.

Referenced by GetLoadedScripts(), OnAfterCompile(), and Unload().

thread_local_

ThreadLocal v8::internal::Debug::thread_local_

private

Definition at line 642 of file debug.h.

Referenced by ActivateStepIn(), ActivateStepOut(), ArchiveDebug(), Break(), break_frame_id(), break_id(), ClearStepIn(), ClearStepNext(), ClearStepOut(), ClearStepping(), debugger_entry(), FramesHaveBeenDropped(), HandleStepIn(), in_debug_scope(), v8::internal::LiveEdit::InitializeThreadLocal(), IsStepping(), PrepareStep(), restarter_frame_function_pointer_address(), RestoreDebug(), v8::internal::LiveEdit::SetAfterBreakTarget(), SetNextBreakId(), step_in_fp_addr(), StepInActive(), StepNextContinue(), StepOutActive(), and ThreadInit().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/debug.h
• /mnt/V8SourceCode/src/debug.cc