mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-29 04:53:56 +08:00
8980e177bb
I noticed that if we step into an inline function, step_1 never
reaches proceed, and thus nevers sets the thread's
tp->control.command_interp. Because of that,
should_print_stop_to_console fails to determine that is should print
stop output to the console.
The fix is to set the thread's command_interp earlier. However, I
realized that we can move that field to the thread_fsm, given that its
lifetime is exactly the same as thread_fsm. So the patch plumbs all
fsms constructors to take the command interp and store it in the
thread_fsm.
We can see the fix in action, with e.g., the gdb.opt/inline-cmds.exp
test, and issuing a step when stopped at line 67:
&"s\n"
^running
*running,thread-id="all"
(gdb)
~"67\t result = func2 ();\n"
*stopped,reason="end-stepping-range",frame={addr="0x00000000004004d0",func="main",args=[],file="/home/pedro/gdb/mygit/src/gdb/testsuite/gdb.opt/inline-cmds.c",fullname="/home/pedro/gdb/mygit/src/gdb/testsuite/gdb.opt/inline-cmds.c",line="67"},thread-id="1",stopped-threads="all",core="0"
(gdb)
s
&"s\n"
^running
*running,thread-id="all"
(gdb)
+ ~"func2 () at /home/pedro/gdb/mygit/src/gdb/testsuite/gdb.opt/inline-cmds.c:67\n"
+ ~"67\t result = func2 ();\n"
*stopped,reason="end-stepping-range",frame={addr="0x00000000004004d0",func="func2",args=[],file="/home/pedro/gdb/mygit/src/gdb/testsuite/gdb.opt/inline-cmds.c",fullname="/home/pedro/gdb/mygit/src/gdb/testsuite/gdb.opt/inline-cmds.c",line="67"},thread-id="1",stopped-threads="all",core="0"
(gdb)
(The inline-cmds.exp command is adjusted to exercise this.)
(Due to the follow_fork change, this also fixes "next N" across a fork
with "set follow-fork child" with "set detach-on-fork on". Commands
that rely on internal breakpoints, like "finish" will still require
more work to migrate breakpoints etc. to the child thread.)
gdb/ChangeLog:
2016-06-21 Pedro Alves <palves@redhat.com>
* breakpoint.c (new_until_break_fsm): Add 'cmd_interp' parameter.
(until_break_fsm_should_stop, until_break_fsm_clean_up): Add
thread parameter.
(until_break_command): Pass command interpreter to thread fsm
ctor.
* cli/cli-interp.c (should_print_stop_to_console): Adjust.
* gdbthread.h (struct thread_control_state) <command_interp>:
Delete field.
* infcall.c (new_call_thread_fsm): Add 'cmd_interp' parameter.
Pass it down.
(call_thread_fsm_should_stop): Add thread parameter.
(call_function_by_hand_dummy): Pass command interpreter to thread
fsm ctor. Pass thread pointer to fsm clean up method.
* infcmd.c: Include interps.h.
(struct step_command_fsm) <thread>: Delete field.
(new_step_command_fsm): Add 'cmd_interp' parameter. Pass it down.
(step_command_fsm_prepare): Remove references to fsm's thread
field.
(step_1): Pass command interpreter to thread
fsm ctor. Pass thread pointer to fsm clean up method.
(step_command_fsm_should_stop, step_command_fsm_clean_up): Add
thread parameter and use it.
(new_until_next_fsm): Add 'cmd_interp' parameter. Pass it down.
(until_next_fsm_should_stop, until_next_fsm_clean_up): Add thread
parameter and use it.
(until_next_command): Pass command interpreter to thread fsm ctor.
(struct finish_command_fsm) <thread>: Delete field.
(finish_command_fsm_ops): Add NULL slot for should_notify_stop.
(new_finish_command_fsm): Add 'cmd_interp' parameter and pass it
down. Remove thread parameter and adjust.
(finish_command_fsm_should_stop, finish_command_fsm_clean_up): Add
thread parameter and use it.
(finish_command): Pass command interpreter to thread fsm ctor.
Don't pass thread.
* infrun.c (follow_fork): Move thread fsm to child fork instead of
command interpreter, only.
(clear_proceed_status_thread): Remove reference to command_interp.
(proceed): Don't record the thread's command interpreter.
(clean_up_just_stopped_threads_fsms): Pass thread to fsm clean_up
method.
(fetch_inferior_event): Pass thread to fsm should_stop method.
* thread-fsm.c (thread_fsm_ctor): Add 'cmd_interp' parameter.
Store it.
(thread_fsm_clean_up, thread_fsm_should_stop): Add thread
parameter and pass it down.
* thread-fsm.h (struct thread_fsm) <command_interp>: New field.
(struct thread_fsm_ops) <clean_up, should_stop>: Add thread
parameter.
(thread_fsm_ctor): Add 'cmd_interp' parameter.
(thread_fsm_clean_up, thread_fsm_should_stop): Add thread
parameter.
* thread.c (thread_cancel_execution_command): Pass thread to
thread fsm clean_up method.
gdb/testsuite/ChangeLog:
2016-06-21 Pedro Alves <palves@redhat.com>
* gdb.opt/inline-cmds.c: Add "set mi break here" marker.
* gdb.opt/inline-cmds.exp: Add MI tests.
110 lines
2.5 KiB
C
110 lines
2.5 KiB
C
/* Thread command's finish-state machine, for GDB, the GNU debugger.
|
|
Copyright (C) 2015-2016 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "thread-fsm.h"
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
void
|
|
thread_fsm_ctor (struct thread_fsm *self, struct thread_fsm_ops *ops,
|
|
struct interp *cmd_interp)
|
|
{
|
|
self->command_interp = cmd_interp;
|
|
self->finished = 0;
|
|
self->ops = ops;
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
void
|
|
thread_fsm_delete (struct thread_fsm *self)
|
|
{
|
|
if (self != NULL)
|
|
{
|
|
if (self->ops->dtor != NULL)
|
|
self->ops->dtor (self);
|
|
xfree (self);
|
|
}
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
void
|
|
thread_fsm_clean_up (struct thread_fsm *self, struct thread_info *thread)
|
|
{
|
|
if (self->ops->clean_up != NULL)
|
|
self->ops->clean_up (self, thread);
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
int
|
|
thread_fsm_should_stop (struct thread_fsm *self, struct thread_info *thread)
|
|
{
|
|
return self->ops->should_stop (self, thread);
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
struct return_value_info *
|
|
thread_fsm_return_value (struct thread_fsm *self)
|
|
{
|
|
if (self->ops->return_value != NULL)
|
|
return self->ops->return_value (self);
|
|
return NULL;
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
void
|
|
thread_fsm_set_finished (struct thread_fsm *self)
|
|
{
|
|
self->finished = 1;
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
int
|
|
thread_fsm_finished_p (struct thread_fsm *self)
|
|
{
|
|
return self->finished;
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
enum async_reply_reason
|
|
thread_fsm_async_reply_reason (struct thread_fsm *self)
|
|
{
|
|
/* If we didn't finish, then the stop reason must come from
|
|
elsewhere. E.g., a breakpoint hit or a signal intercepted. */
|
|
gdb_assert (thread_fsm_finished_p (self));
|
|
|
|
return self->ops->async_reply_reason (self);
|
|
}
|
|
|
|
/* See thread-fsm.h. */
|
|
|
|
int
|
|
thread_fsm_should_notify_stop (struct thread_fsm *self)
|
|
{
|
|
if (self->ops->should_notify_stop != NULL)
|
|
return self->ops->should_notify_stop (self);
|
|
return 1;
|
|
}
|