FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* infttrace.c (child_resume): Simplify and rework to avoid

Browse source 
TT_PROC_CONTINUE.
This commit is contained in:
Jeff Law 2002-09-10 17:34:05 +00:00
parent b3018b5f70
commit da12f4d874
2 changed files with 28 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
gdb/ChangeLog
View file

@ -1,3 +1,8 @@
2002-09-10 Jeff Law <law@redhat.com>
* infttrace.c (child_resume): Simplify and rework to avoid
TT_PROC_CONTINUE.
2002-09-09 Fred Fish <fnf@intrinsity.com> 2002-09-09 Fred Fish <fnf@intrinsity.com>
* printcmd.c (print_scalar_formatted): "len" is the number of * printcmd.c (print_scalar_formatted): "len" is the number of

103
gdb/infttrace.c
View file

@ -4539,98 +4539,41 @@ child_resume (ptid_t ptid, int step, enum target_signal signal)
else else
{ {
/* TT_LWP_CONTINUE can pass signals to threads, /* TT_LWP_CONTINUE can pass signals to threads, TT_PROC_CONTINUE can't.
* TT_PROC_CONTINUE can't. So if there are any Therefore, we really can't use TT_PROC_CONTINUE here.
* signals to pass, we have to use the (slower)
* loop over the stopped threads. Consider a process which stopped due to signal which gdb decides
* to handle and not pass on to the inferior. In that case we must
* Equally, if we have to not continue some threads, clear the pending signal by restarting the inferior using
* due to saved events, we have to use the loop. TT_LWP_CONTINUE and pass zero as the signal number. Else the
*/ pending signal will be passed to the inferior. interrupt.exp
if ((signal != 0) || saved_signals_exist ()) in the testsuite does this precise thing and fails due to the
unwanted signal delivery to the inferior. */
if (resume_all_threads)
{ {
if (resume_all_threads)
{
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
if (debug_on) if (debug_on)
printf ("Doing a continue by loop of all threads\n"); printf ("Doing a continue by loop of all threads\n");
#endif #endif
threads_continue_all_with_signals (tid, signal); threads_continue_all_with_signals (tid, signal);
clear_all_handled (); clear_all_handled ();
clear_all_stepping_mode (); clear_all_stepping_mode ();
}
else
{
#ifdef THREAD_DEBUG
printf ("Doing a continue w/signal of just thread %d\n", tid);
#endif
threads_continue_one_with_signal (tid, signal);
/* Clear the "handled" state of this thread, because
* we'll soon get a new event for it. Other events
* can stay as they were.
*/
clear_handled (tid);
clear_stepping_mode (tid);
}
} }
else else
{ {
/* No signals to send.
*/
if (resume_all_threads)
{
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
if (debug_on) printf ("Doing a continue w/signal of just thread %d\n", tid);
printf ("Doing a continue by process of process %d\n", tid);
#endif #endif
if (more_events_left > 0) threads_continue_one_with_signal (tid, signal);
{
warning ("Losing buffered events on continue.");
more_events_left = 0;
}
call_ttrace (TT_PROC_CONTINUE, /* Clear the "handled" state of this thread, because we
tid, will soon get a new event for it. Other events can
TT_NIL, stay as they were. */
TT_NIL, clear_handled (tid);
TT_NIL); clear_stepping_mode (tid);
clear_all_handled ();
clear_all_stepping_mode ();
}
else
{
#ifdef THREAD_DEBUG
if (debug_on)
{
printf ("Doing a continue of just thread %d\n", tid);
if (is_terminated (tid))
printf ("Why are we continuing a dead thread? (5)\n");
}
#endif
call_ttrace (TT_LWP_CONTINUE,
tid,
TT_NIL,
TT_NIL,
TT_NIL);
/* Clear the "handled" state of this thread, because
* we'll soon get a new event for it. Other events
* can stay as they were.
*/
clear_handled (tid);
clear_stepping_mode (tid);
}
} }
} }