From 0b080f5982d636d473d4fb9e62ef1ee00b28fdbc Mon Sep 17 00:00:00 2001 From: Vladimir Prus Date: Tue, 10 Jun 2008 09:29:15 +0000 Subject: [PATCH] Introduce common cleanup for restoring integers. * defs.h (make_cleanup_restore_integer): New declaration. (struct cleanup): New field free_arg. (make_my_cleanup_2): New. * utils.c (restore_integer_closure, restore_integer) (make_cleanup_restore_integer): New. (make_my_cleanup): Initialize the free_arg field and renamed to make_my_cleanup_2. (do_my_cleanups): Call free_arg. (discard_cleanups): Call free_arg. * breakpoint.c (restore_always_inserted_mode): Remove. (update_breakpoints_after_exec): Use make_cleanup_restore_integer. --- gdb/ChangeLog | 15 +++++++++++++++ gdb/breakpoint.c | 9 +-------- gdb/defs.h | 14 +++++++++++++- gdb/utils.c | 42 ++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 69 insertions(+), 11 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 71e9df5f9e1..a00c5fa30ea 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,18 @@ +2008-06-10 Vladimir Prus + + Introduce common cleanup for restoring integers. + * defs.h (make_cleanup_restore_integer): New declaration. + (struct cleanup): New field free_arg. + (make_my_cleanup_2): New. + * utils.c (restore_integer_closure, restore_integer) + (make_cleanup_restore_integer): New. + (make_my_cleanup): Initialize the free_arg field and + renamed to make_my_cleanup_2. + (do_my_cleanups): Call free_arg. + (discard_cleanups): Call free_arg. + * breakpoint.c (restore_always_inserted_mode): Remove. + (update_breakpoints_after_exec): Use make_cleanup_restore_integer. + 2008-06-09 Doug Evans * remote.c (remote_wait): Include beginning of malformed packet diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 051b753d639..dd7bf12ec24 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -1435,12 +1435,6 @@ reattach_breakpoints (int pid) return 0; } -static void -restore_always_inserted_mode (void *p) -{ - always_inserted_mode = (uintptr_t) p; -} - void update_breakpoints_after_exec (void) { @@ -1456,8 +1450,7 @@ update_breakpoints_after_exec (void) /* The binary we used to debug is now gone, and we're updating breakpoints for the new binary. Until we're done, we should not try to insert breakpoints. */ - cleanup = make_cleanup (restore_always_inserted_mode, - (void *) (uintptr_t) always_inserted_mode); + cleanup = make_cleanup_restore_integer (&always_inserted_mode); always_inserted_mode = 0; ALL_BREAKPOINTS_SAFE (b, temp) diff --git a/gdb/defs.h b/gdb/defs.h index 906915680f1..ca3fad82cb4 100644 --- a/gdb/defs.h +++ b/gdb/defs.h @@ -230,12 +230,18 @@ enum return_value_convention Use make_cleanup to add an element to the cleanup chain. Use do_cleanups to do all cleanup actions back to a given point in the chain. Use discard_cleanups to remove cleanups - from the chain back to a given point, not doing them. */ + from the chain back to a given point, not doing them. + + If the argument is pointer to allocated memory, then you need to + to additionally set the 'free_arg' member to a function that will + free that memory. This function will be called both when the cleanup + is executed and when it's discarded. */ struct cleanup { struct cleanup *next; void (*function) (void *); + void (*free_arg) (void *); void *arg; }; @@ -339,11 +345,17 @@ extern struct cleanup *make_cleanup_close (int fd); extern struct cleanup *make_cleanup_bfd_close (bfd *abfd); +extern struct cleanup *make_cleanup_restore_integer (int *variable); + extern struct cleanup *make_final_cleanup (make_cleanup_ftype *, void *); extern struct cleanup *make_my_cleanup (struct cleanup **, make_cleanup_ftype *, void *); +extern struct cleanup *make_my_cleanup2 (struct cleanup **, + make_cleanup_ftype *, void *, + void (*free_arg) (void *)); + extern struct cleanup *save_cleanups (void); extern struct cleanup *save_final_cleanups (void); extern struct cleanup *save_my_cleanups (struct cleanup **); diff --git a/gdb/utils.c b/gdb/utils.c index 76ea6b12b8f..cdea5a66394 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -277,10 +277,36 @@ make_cleanup_free_section_addr_info (struct section_addr_info *addrs) return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs); } +struct restore_integer_closure +{ + int *variable; + int value; +}; + +static void +restore_integer (void *p) +{ + struct restore_integer_closure *closure = p; + *(closure->variable) = closure->value; +} +/* Remember the current value of *VARIABLE and make it restored when the cleanup + is run. */ struct cleanup * -make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, - void *arg) +make_cleanup_restore_integer (int *variable) +{ + struct restore_integer_closure *c = + xmalloc (sizeof (struct restore_integer_closure)); + c->variable = variable; + c->value = *variable; + + return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c, + xfree); +} + +struct cleanup * +make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function, + void *arg, void (*free_arg) (void *)) { struct cleanup *new = (struct cleanup *) xmalloc (sizeof (struct cleanup)); @@ -288,12 +314,20 @@ make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, new->next = *pmy_chain; new->function = function; + new->free_arg = free_arg; new->arg = arg; *pmy_chain = new; return old_chain; } +struct cleanup * +make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function, + void *arg) +{ + return make_my_cleanup2 (pmy_chain, function, arg, NULL); +} + /* Discard cleanups and do the actions they describe until we get back to the point OLD_CHAIN in the cleanup_chain. */ @@ -318,6 +352,8 @@ do_my_cleanups (struct cleanup **pmy_chain, { *pmy_chain = ptr->next; /* Do this first incase recursion */ (*ptr->function) (ptr->arg); + if (ptr->free_arg) + (*ptr->free_arg) (ptr->arg); xfree (ptr); } } @@ -345,6 +381,8 @@ discard_my_cleanups (struct cleanup **pmy_chain, while ((ptr = *pmy_chain) != old_chain) { *pmy_chain = ptr->next; + if (ptr->free_arg) + (*ptr->free_arg) (ptr->arg); xfree (ptr); } } -- 2.30.2