gdb: Replace make_bpstat_clear_actions_cleanup
Commit Message
Replace make_bpstat_clear_actions_cleanup with a new class that can
perform the cleanup.
gdb/ChangeLog:
* breakpoint.c (bpstat_clear_actions): Rename to...
(scoped_bpstat_clear_actions::do_bpstat_clear_actions): ...this.
(bpstat_do_actions): Switch from using
make_bpstat_clear_actions_cleanup to use
scoped_bpstat_clear_actions.
* breakpoint.h (class scoped_bpstat_clear_actions): New.
* infrun.c (fetch_inferior_event): Switch from using
make_bpstat_clear_actions_cleanup to use
scoped_bpstat_clear_actions.
* top.c (execute_command): Likewise.
* utils.c (do_bpstat_clear_actions_cleanup): Delete.
(make_bpstat_clear_actions_cleanup): Delete.
* utils.h (make_bpstat_clear_actions_cleanup): Delete.
---
gdb/ChangeLog | 16 ++++++++++++++++
gdb/breakpoint.c | 6 +++---
gdb/breakpoint.h | 33 +++++++++++++++++++++++++++++++++
gdb/infrun.c | 6 ++++--
gdb/top.c | 7 +++----
gdb/utils.c | 17 -----------------
gdb/utils.h | 1 -
7 files changed, 59 insertions(+), 27 deletions(-)
Comments
>>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:
Andrew> Replace make_bpstat_clear_actions_cleanup with a new class that can
Andrew> perform the cleanup.
Hah, I took a stab at this too. I started with something like your
patch but generalized it to a cleanup_function that takes a
function_view as a callback. This allowed for the removal of some more
cleanups. See my branch submit/cleanup/longjmp-bp.
I wonder what you think of that approach. I was on the fence about it
myself. On the one hand, it's pretty simple to understand and it fits a
number of existing spots in gdb. On the other hand, maybe it's a bit
too easy to get into trouble with something generic.
If you try the branch, be warned it still has some regressions, which is
why I haven't submitted it yet.
Tom
>>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:
Andrew> Replace make_bpstat_clear_actions_cleanup with a new class that can
Andrew> perform the cleanup.
Andrew> gdb/ChangeLog:
Andrew> * breakpoint.c (bpstat_clear_actions): Rename to...
Andrew> (scoped_bpstat_clear_actions::do_bpstat_clear_actions): ...this.
Andrew> (bpstat_do_actions): Switch from using
Andrew> make_bpstat_clear_actions_cleanup to use
Andrew> scoped_bpstat_clear_actions.
Andrew> * breakpoint.h (class scoped_bpstat_clear_actions): New.
Andrew> * infrun.c (fetch_inferior_event): Switch from using
Andrew> make_bpstat_clear_actions_cleanup to use
Andrew> scoped_bpstat_clear_actions.
Andrew> * top.c (execute_command): Likewise.
Andrew> * utils.c (do_bpstat_clear_actions_cleanup): Delete.
Andrew> (make_bpstat_clear_actions_cleanup): Delete.
Andrew> * utils.h (make_bpstat_clear_actions_cleanup): Delete.
BTW, this is ok. There's no need to wait on some other series that
hasn't been sent.
Andrew> void
Andrew> -bpstat_clear_actions (void)
Andrew> +scoped_bpstat_clear_actions::do_bpstat_clear_actions (void)
I looked more closely, and this approach is actually a bit more
"integrated" (not sure what word to use) than mine, as mine left
bpstat_clear_actions as an ordinary function. So perhaps this is a
better way to go.
Tom
* Tom Tromey <tom@tromey.com> [2019-01-07 08:27:08 -0700]:
> >>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:
>
> Andrew> Replace make_bpstat_clear_actions_cleanup with a new class that can
> Andrew> perform the cleanup.
>
> Hah, I took a stab at this too. I started with something like your
> patch but generalized it to a cleanup_function that takes a
> function_view as a callback. This allowed for the removal of some more
> cleanups. See my branch submit/cleanup/longjmp-bp.
>
> I wonder what you think of that approach. I was on the fence about it
> myself. On the one hand, it's pretty simple to understand and it fits a
> number of existing spots in gdb. On the other hand, maybe it's a bit
> too easy to get into trouble with something generic.
>
> If you try the branch, be warned it still has some regressions, which is
> why I haven't submitted it yet.
I haven't tried the branch, but I did take a look. I've had similar
thoughts for a while (that we could have a generic object that called
the existing cleanup functions) but I always figured we preferred more
specialised classes as that was what seemed to be getting submitted...
...personally I don't see any problem with having a generic cleanup
object for cases where a single function call is needed. As you point
out in the other mail in this thread, I did pull the cleanup function
into the cleanup object in my patch, but as the cleanup here is just a
series of calls to global functions (there's no significant state in
the cleanup class) I don't see that as a huge advantage.
Did you see extending the work in your branch to remove existing
specialised cleanup objects where possible? I suspect many could be
replaced with your generic approach, but one concrete example (only
picked because it was the first I found) is gdbthread.c:class
scoped_finish_thread_state.
Thanks,
Andrew
>>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:
Andrew> I haven't tried the branch, but I did take a look. I've had similar
Andrew> thoughts for a while (that we could have a generic object that called
Andrew> the existing cleanup functions) but I always figured we preferred more
Andrew> specialised classes as that was what seemed to be getting submitted...
Andrew> ...personally I don't see any problem with having a generic cleanup
Andrew> object for cases where a single function call is needed. As you point
Andrew> out in the other mail in this thread, I did pull the cleanup function
Andrew> into the cleanup object in my patch, but as the cleanup here is just a
Andrew> series of calls to global functions (there's no significant state in
Andrew> the cleanup class) I don't see that as a huge advantage.
Andrew> Did you see extending the work in your branch to remove existing
Andrew> specialised cleanup objects where possible? I suspect many could be
Andrew> replaced with your generic approach, but one concrete example (only
Andrew> picked because it was the first I found) is gdbthread.c:class
Andrew> scoped_finish_thread_state.
First, thanks for your (off-list) review. You found the bug.
For the record the bug was something like
gdb::optional<mumble> cleanup;
...
cleanup.reset ();
... where what was meant was:
cleanup->reset ();
I renamed the cleanup_function's method to "cancel" to try to avoid this
problem in the future.
I looked at replacing scoped_finish_thread_state, but that one seemed
reasonable to keep as is, to me, because it is used in several spots,
and I didn't want to repeat the similar lambdas everywhere.
I did replace regcache_invalidator, on the theory that since there was
only a single use, it was no big deal to introduce a new lambda.
Tom
@@ -4320,7 +4320,7 @@ bpstat_num (bpstat *bsp, int *num)
/* See breakpoint.h. */
void
-bpstat_clear_actions (void)
+scoped_bpstat_clear_actions::do_bpstat_clear_actions (void)
{
bpstat bs;
@@ -4473,7 +4473,7 @@ get_bpstat_thread ()
void
bpstat_do_actions (void)
{
- struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
+ scoped_bpstat_clear_actions bpstat_clear_actions;
thread_info *tp;
/* Do any commands attached to breakpoint we are stopped at. */
@@ -4487,7 +4487,7 @@ bpstat_do_actions (void)
break;
}
- discard_cleanups (cleanup_if_error);
+ bpstat_clear_actions.release ();
}
/* Print out the (old or new) value associated with a watchpoint. */
@@ -1682,4 +1682,37 @@ extern void print_breakpoint (breakpoint *bp);
/* Command element for the 'commands' command. */
extern cmd_list_element *commands_cmd_element;
+/* Create an instance of this class in order to clear bpstat actions if an
+ exception is thrown. Call the RELEASE member function in the clean
+ return case. */
+
+class scoped_bpstat_clear_actions
+{
+public:
+ scoped_bpstat_clear_actions ()
+ { /* Nothing. */ }
+
+ /* Destructor. Clears partial bpstat actions if an exception occurs. */
+ ~scoped_bpstat_clear_actions ()
+ {
+ if (!m_released)
+ do_bpstat_clear_actions ();
+ }
+
+ /* Called once the clearing is no longer needed. */
+ void release ()
+ {
+ m_released = true;
+ }
+
+ DISABLE_COPY_AND_ASSIGN (scoped_bpstat_clear_actions);
+
+private:
+ /* Set true when the clear is no longer needed. */
+ bool m_released = false;
+
+ /* Worker function that does the actual clear, called from destructor. */
+ void do_bpstat_clear_actions ();
+};
+
#endif /* !defined (BREAKPOINT_H) */
@@ -3758,9 +3758,10 @@ fetch_inferior_event (void *client_data)
/* Get executed before make_cleanup_restore_current_thread above to apply
still for the thread which has thrown the exception. */
- struct cleanup *ts_old_chain = make_bpstat_clear_actions_cleanup ();
+ scoped_bpstat_clear_actions bpstat_clear_actions;
- make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
+ struct cleanup *ts_old_chain
+ = make_cleanup (delete_just_stopped_threads_infrun_breakpoints_cleanup, NULL);
/* Now figure out what to do with the result of the result. */
handle_inferior_event (ecs);
@@ -3813,6 +3814,7 @@ fetch_inferior_event (void *client_data)
}
}
+ bpstat_clear_actions.release ();
discard_cleanups (ts_old_chain);
/* No error, don't finish the thread states yet. */
@@ -539,12 +539,11 @@ set_repeat_arguments (const char *args)
void
execute_command (const char *p, int from_tty)
{
- struct cleanup *cleanup_if_error;
struct cmd_list_element *c;
const char *line;
const char *cmd_start = p;
- cleanup_if_error = make_bpstat_clear_actions_cleanup ();
+ scoped_bpstat_clear_actions bpstat_clear_actions;
scoped_value_mark cleanup = prepare_execute_command ();
/* Force cleanup of any alloca areas if using C alloca instead of
@@ -554,7 +553,7 @@ execute_command (const char *p, int from_tty)
/* This can happen when command_line_input hits end of file. */
if (p == NULL)
{
- discard_cleanups (cleanup_if_error);
+ bpstat_clear_actions.release ();
return;
}
@@ -649,7 +648,7 @@ execute_command (const char *p, int from_tty)
if (has_stack_frames () && inferior_thread ()->state != THREAD_RUNNING)
check_frame_language_change ();
- discard_cleanups (cleanup_if_error);
+ bpstat_clear_actions.release ();
}
/* Run execute_command for P and FROM_TTY. Capture its output into the
@@ -3057,23 +3057,6 @@ parse_pid_to_attach (const char *args)
return pid;
}
-/* Helper for make_bpstat_clear_actions_cleanup. */
-
-static void
-do_bpstat_clear_actions_cleanup (void *unused)
-{
- bpstat_clear_actions ();
-}
-
-/* Call bpstat_clear_actions for the case an exception is throw. You should
- discard_cleanups if no exception is caught. */
-
-struct cleanup *
-make_bpstat_clear_actions_cleanup (void)
-{
- return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
-}
-
/* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
must come from xrealloc-compatible allocator and it may be updated. FROM
needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
@@ -286,7 +286,6 @@ private:
int m_save_batch_flag;
};
-extern struct cleanup *make_bpstat_clear_actions_cleanup (void);
/* Path utilities. */