diff mbox

gdb: Replace make_bpstat_clear_actions_cleanup

Message ID 20190107124354.17415-1-andrew.burgess@embecosm.com
State New
Headers show

Commit Message

Andrew Burgess Jan. 7, 2019, 12:43 p.m. UTC
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

Tom Tromey Jan. 7, 2019, 3:27 p.m. UTC | #1
>>>>> "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
Tom Tromey Jan. 7, 2019, 3:40 p.m. UTC | #2
>>>>> "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
Andrew Burgess Jan. 8, 2019, 12:55 p.m. UTC | #3
* 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
Tom Tromey Jan. 9, 2019, 12:52 a.m. UTC | #4
>>>>> "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
diff mbox

Patch

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index d54d4969726..e33f1eaf02c 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -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.  */
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 97b6f3fbc64..d3a55e58a4a 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -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) */
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 150288264f4..ac1322dd6be 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -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.  */
diff --git a/gdb/top.c b/gdb/top.c
index 900e78aaec5..e7b986d0598 100644
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -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
diff --git a/gdb/utils.c b/gdb/utils.c
index ed8d60fa7b0..4af75e34809 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -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
diff --git a/gdb/utils.h b/gdb/utils.h
index f2fe1da832c..896feb973c9 100644
--- a/gdb/utils.h
+++ b/gdb/utils.h
@@ -286,7 +286,6 @@  private:
   int m_save_batch_flag;
 };
 
-extern struct cleanup *make_bpstat_clear_actions_cleanup (void);
 
 /* Path utilities.  */