From 73971819031d74eb846805a9fbfad04ba1dff500 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Wed, 10 Aug 2016 23:03:29 +0100 Subject: Plumb enum remove_bp_reason all the way to target_remove_breakpoint So the target knows whether we're detaching breakpoints. Nothing uses the parameter in this patch yet. gdb/ChangeLog: 2016-08-10 Pedro Alves PR gdb/19187 * break-catch-sig.c (signal_catchpoint_remove_location): Adjust interface. * break-catch-syscall.c (remove_catch_syscall): * breakpoint.c (enum remove_bp_reason): Moved to breakpoint.h. (remove_breakpoint_1): Pass 'reason' down. (remove_catch_fork, remove_catch_vfork, remove_catch_solib) (remove_catch_exec, remove_watchpoint, remove_masked_watchpoint) (base_breakpoint_remove_location, bkpt_remove_location) (bkpt_probe_remove_location, bkpt_probe_remove_location): Adjust interface. * breakpoint.h (enum remove_bp_reason): Moved here from breakpoint.c. (struct breakpoint_ops) : Add 'reason' parameter. * corelow.c (core_remove_breakpoint): New function. (init_core_ops): Install it as to_remove_breakpoint method. * exec.c (exec_remove_breakpoint): New function. (init_exec_ops): Install it as to_remove_breakpoint method. * mem-break.c (memory_remove_breakpoint): Adjust interface. * record-btrace.c (record_btrace_remove_breakpoint): Adjust interface. * record-full.c (record_full_remove_breakpoint) (record_full_core_remove_breakpoint): Adjust interface. * remote.c (remote_remove_breakpoint): Adjust interface. * target-debug.h (target_debug_print_enum_remove_bp_reason): New macro. * target-delegates.c: Regenerate. * target.c (target_remove_breakpoint): Add 'reason' parameter. * target.h (struct target_ops) : Add 'reason' parameter. (target_remove_breakpoint, memory_remove_breakpoint): Add 'reason' parameter. --- gdb/ChangeLog | 35 +++++++++++++++++++++++++++++++++++ gdb/break-catch-sig.c | 3 ++- gdb/break-catch-syscall.c | 2 +- gdb/breakpoint.c | 47 +++++++++++++++++++---------------------------- gdb/breakpoint.h | 14 +++++++++++++- gdb/corelow.c | 12 +++++++++++- gdb/exec.c | 12 +++++++++++- gdb/mem-break.c | 3 ++- gdb/nto-procfs.c | 3 ++- gdb/record-btrace.c | 6 ++++-- gdb/record-full.c | 8 +++++--- gdb/remote.c | 5 +++-- gdb/target-debug.h | 2 ++ gdb/target-delegates.c | 10 ++++++---- gdb/target.c | 5 +++-- gdb/target.h | 9 ++++++--- 16 files changed, 125 insertions(+), 51 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index b18b27ac8cf..bdd28feef95 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,38 @@ +2016-08-10 Pedro Alves + + PR gdb/19187 + * break-catch-sig.c (signal_catchpoint_remove_location): Adjust + interface. + * break-catch-syscall.c (remove_catch_syscall): + * breakpoint.c (enum remove_bp_reason): Moved to breakpoint.h. + (remove_breakpoint_1): Pass 'reason' down. + (remove_catch_fork, remove_catch_vfork, remove_catch_solib) + (remove_catch_exec, remove_watchpoint, remove_masked_watchpoint) + (base_breakpoint_remove_location, bkpt_remove_location) + (bkpt_probe_remove_location, bkpt_probe_remove_location): Adjust + interface. + * breakpoint.h (enum remove_bp_reason): Moved here from + breakpoint.c. + (struct breakpoint_ops) : Add 'reason' parameter. + * corelow.c (core_remove_breakpoint): New function. + (init_core_ops): Install it as to_remove_breakpoint method. + * exec.c (exec_remove_breakpoint): New function. + (init_exec_ops): Install it as to_remove_breakpoint method. + * mem-break.c (memory_remove_breakpoint): Adjust interface. + * record-btrace.c (record_btrace_remove_breakpoint): Adjust + interface. + * record-full.c (record_full_remove_breakpoint) + (record_full_core_remove_breakpoint): Adjust interface. + * remote.c (remote_remove_breakpoint): Adjust interface. + * target-debug.h (target_debug_print_enum_remove_bp_reason): New + macro. + * target-delegates.c: Regenerate. + * target.c (target_remove_breakpoint): Add 'reason' parameter. + * target.h (struct target_ops) : Add + 'reason' parameter. + (target_remove_breakpoint, memory_remove_breakpoint): Add 'reason' + parameter. + 2016-08-10 Pedro Alves PR gdb/19187 diff --git a/gdb/break-catch-sig.c b/gdb/break-catch-sig.c index dcfae42489d..06ee44c1ca9 100644 --- a/gdb/break-catch-sig.c +++ b/gdb/break-catch-sig.c @@ -137,7 +137,8 @@ signal_catchpoint_insert_location (struct bp_location *bl) catchpoints. */ static int -signal_catchpoint_remove_location (struct bp_location *bl) +signal_catchpoint_remove_location (struct bp_location *bl, + enum remove_bp_reason reason) { struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner; int i; diff --git a/gdb/break-catch-syscall.c b/gdb/break-catch-syscall.c index 602aba4e935..63b8cd296e2 100644 --- a/gdb/break-catch-syscall.c +++ b/gdb/break-catch-syscall.c @@ -158,7 +158,7 @@ insert_catch_syscall (struct bp_location *bl) catchpoints. */ static int -remove_catch_syscall (struct bp_location *bl) +remove_catch_syscall (struct bp_location *bl, enum remove_bp_reason reason) { struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner; struct inferior *inf = current_inferior (); diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 6c36d1a6c87..6bb6bbfbef9 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -194,18 +194,6 @@ static void commands_command (char *, int); static void condition_command (char *, int); -/* Why are we removing the breakpoint from the target? */ - -enum remove_bp_reason -{ - /* A regular remove. Remove the breakpoint and forget everything - about it. */ - REMOVE_BREAKPOINT, - - /* Detach the breakpoints from a fork child. */ - DETACH_BREAKPOINT, -}; - static int remove_breakpoint (struct bp_location *); static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason); @@ -3996,7 +3984,7 @@ remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason) && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info)) val = 0; else - val = bl->owner->ops->remove_location (bl); + val = bl->owner->ops->remove_location (bl, reason); } else { @@ -4014,7 +4002,8 @@ remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason) &bl->overlay_target_info); else target_remove_breakpoint (bl->gdbarch, - &bl->overlay_target_info); + &bl->overlay_target_info, + reason); } /* Did we set a breakpoint at the VMA? If so, we will have marked the breakpoint 'inserted'. */ @@ -4030,7 +4019,7 @@ remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason) wrong code with the saved shadow contents. */ if (bl->loc_type == bp_loc_hardware_breakpoint || section_is_mapped (bl->section)) - val = bl->owner->ops->remove_location (bl); + val = bl->owner->ops->remove_location (bl, reason); else val = 0; } @@ -4068,7 +4057,7 @@ remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason) && bl->owner->ops->remove_location != NULL); bl->inserted = (reason == DETACH_BREAKPOINT); - bl->owner->ops->remove_location (bl); + bl->owner->ops->remove_location (bl, reason); /* Failure to remove any of the hardware watchpoints comes here. */ if (reason == REMOVE_BREAKPOINT && bl->inserted) @@ -4082,7 +4071,7 @@ remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason) gdb_assert (bl->owner->ops != NULL && bl->owner->ops->remove_location != NULL); - val = bl->owner->ops->remove_location (bl); + val = bl->owner->ops->remove_location (bl, reason); if (val) return val; @@ -8120,7 +8109,7 @@ insert_catch_fork (struct bp_location *bl) catchpoints. */ static int -remove_catch_fork (struct bp_location *bl) +remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason) { return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid)); } @@ -8238,7 +8227,7 @@ insert_catch_vfork (struct bp_location *bl) catchpoints. */ static int -remove_catch_vfork (struct bp_location *bl) +remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason) { return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid)); } @@ -8381,7 +8370,7 @@ insert_catch_solib (struct bp_location *ignore) } static int -remove_catch_solib (struct bp_location *ignore) +remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason) { return 0; } @@ -8711,7 +8700,7 @@ insert_catch_exec (struct bp_location *bl) } static int -remove_catch_exec (struct bp_location *bl) +remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason) { return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid)); } @@ -10720,7 +10709,7 @@ insert_watchpoint (struct bp_location *bl) /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */ static int -remove_watchpoint (struct bp_location *bl) +remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason) { struct watchpoint *w = (struct watchpoint *) bl->owner; int length = w->exact ? 1 : bl->length; @@ -10975,7 +10964,7 @@ insert_masked_watchpoint (struct bp_location *bl) masked hardware watchpoints. */ static int -remove_masked_watchpoint (struct bp_location *bl) +remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason) { struct watchpoint *w = (struct watchpoint *) bl->owner; @@ -12971,7 +12960,8 @@ base_breakpoint_insert_location (struct bp_location *bl) } static int -base_breakpoint_remove_location (struct bp_location *bl) +base_breakpoint_remove_location (struct bp_location *bl, + enum remove_bp_reason reason) { internal_error_pure_virtual_called (); } @@ -13133,12 +13123,12 @@ bkpt_insert_location (struct bp_location *bl) } static int -bkpt_remove_location (struct bp_location *bl) +bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason) { if (bl->loc_type == bp_loc_hardware_breakpoint) return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info); else - return target_remove_breakpoint (bl->gdbarch, &bl->target_info); + return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason); } static int @@ -13481,7 +13471,8 @@ bkpt_probe_insert_location (struct bp_location *bl) } static int -bkpt_probe_remove_location (struct bp_location *bl) +bkpt_probe_remove_location (struct bp_location *bl, + enum remove_bp_reason reason) { /* Let's clear the semaphore before removing the location. */ if (bl->probe.probe->pops->clear_semaphore != NULL) @@ -13489,7 +13480,7 @@ bkpt_probe_remove_location (struct bp_location *bl) bl->probe.objfile, bl->gdbarch); - return bkpt_remove_location (bl); + return bkpt_remove_location (bl, reason); } static void diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 5f06772d6f5..4bdf0d5b40d 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -39,6 +39,18 @@ struct linespec_result; struct linespec_sals; struct event_location; +/* Why are we removing the breakpoint from the target? */ + +enum remove_bp_reason +{ + /* A regular remove. Remove the breakpoint and forget everything + about it. */ + REMOVE_BREAKPOINT, + + /* Detach the breakpoints from a fork child. */ + DETACH_BREAKPOINT, +}; + /* This is the maximum number of bytes a breakpoint instruction can take. Feel free to increase it. It's just used in a few places to size arrays that should be independent of the target @@ -519,7 +531,7 @@ struct breakpoint_ops with the "insert" method above. Return 0 for success, 1 if the breakpoint, watchpoint or catchpoint type is not supported, -1 for failure. */ - int (*remove_location) (struct bp_location *); + int (*remove_location) (struct bp_location *, enum remove_bp_reason reason); /* Return true if it the target has stopped due to hitting breakpoint location BL. This function does not check if we diff --git a/gdb/corelow.c b/gdb/corelow.c index 224719e8b32..376b7c9fd90 100644 --- a/gdb/corelow.c +++ b/gdb/corelow.c @@ -920,6 +920,16 @@ ignore (struct target_ops *ops, struct gdbarch *gdbarch, return 0; } +/* Implement the to_remove_breakpoint method. */ + +static int +core_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) +{ + return 0; +} + /* Okay, let's be honest: threads gleaned from a core file aren't exactly lively, are they? On the other hand, if we don't claim @@ -1043,7 +1053,7 @@ init_core_ops (void) core_ops.to_xfer_partial = core_xfer_partial; core_ops.to_files_info = core_files_info; core_ops.to_insert_breakpoint = ignore; - core_ops.to_remove_breakpoint = ignore; + core_ops.to_remove_breakpoint = core_remove_breakpoint; core_ops.to_thread_alive = core_thread_alive; core_ops.to_read_description = core_read_description; core_ops.to_pid_to_str = core_pid_to_str; diff --git a/gdb/exec.c b/gdb/exec.c index c998ab19bd2..00c31d37da6 100644 --- a/gdb/exec.c +++ b/gdb/exec.c @@ -1075,6 +1075,16 @@ ignore (struct target_ops *ops, struct gdbarch *gdbarch, return 0; } +/* Implement the to_remove_breakpoint method. */ + +static int +exec_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) +{ + return 0; +} + static int exec_has_memory (struct target_ops *ops) { @@ -1106,7 +1116,7 @@ Specify the filename of the executable file."; exec_ops.to_get_section_table = exec_get_section_table; exec_ops.to_files_info = exec_files_info; exec_ops.to_insert_breakpoint = ignore; - exec_ops.to_remove_breakpoint = ignore; + exec_ops.to_remove_breakpoint = exec_remove_breakpoint; exec_ops.to_stratum = file_stratum; exec_ops.to_has_memory = exec_has_memory; exec_ops.to_make_corefile_notes = exec_make_note_section; diff --git a/gdb/mem-break.c b/gdb/mem-break.c index 9bb4c454df0..803f62b704b 100644 --- a/gdb/mem-break.c +++ b/gdb/mem-break.c @@ -93,7 +93,8 @@ memory_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, int memory_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { return gdbarch_memory_remove_breakpoint (gdbarch, bp_tgt); } diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c index f49453d733b..f358528b949 100644 --- a/gdb/nto-procfs.c +++ b/gdb/nto-procfs.c @@ -1004,7 +1004,8 @@ procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, static int procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); } diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 4a51b8e11d0..d50d5d8b850 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -1433,7 +1433,8 @@ record_btrace_insert_breakpoint (struct target_ops *ops, static int record_btrace_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { const char *old; int ret; @@ -1446,7 +1447,8 @@ record_btrace_remove_breakpoint (struct target_ops *ops, ret = 0; TRY { - ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt); + ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, bp_tgt, + reason); } CATCH (except, RETURN_MASK_ALL) { diff --git a/gdb/record-full.c b/gdb/record-full.c index 0f61bcb69d6..4134f395e6b 100644 --- a/gdb/record-full.c +++ b/gdb/record-full.c @@ -1703,7 +1703,8 @@ record_full_insert_breakpoint (struct target_ops *ops, static int record_full_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { struct record_full_breakpoint *bp; int ix; @@ -1723,7 +1724,7 @@ record_full_remove_breakpoint (struct target_ops *ops, old_cleanups = record_full_gdb_operation_disable_set (); ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch, - bp_tgt); + bp_tgt, reason); do_cleanups (old_cleanups); if (ret != 0) @@ -2190,7 +2191,8 @@ record_full_core_insert_breakpoint (struct target_ops *ops, static int record_full_core_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { return 0; } diff --git a/gdb/remote.c b/gdb/remote.c index 79449836307..910ac813860 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -9335,7 +9335,8 @@ Target doesn't support breakpoints that have target side commands.")); static int remote_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { CORE_ADDR addr = bp_tgt->placed_address; struct remote_state *rs = get_remote_state (); @@ -9364,7 +9365,7 @@ remote_remove_breakpoint (struct target_ops *ops, return (rs->buf[0] == 'E'); } - return memory_remove_breakpoint (ops, gdbarch, bp_tgt); + return memory_remove_breakpoint (ops, gdbarch, bp_tgt, reason); } static enum Z_packet_type diff --git a/gdb/target-debug.h b/gdb/target-debug.h index 5f44d1112c0..ef7e14d31d1 100644 --- a/gdb/target-debug.h +++ b/gdb/target-debug.h @@ -158,6 +158,8 @@ target_debug_do_print (plongest (X)) #define target_debug_print_struct_inferior_p(X) \ target_debug_do_print (host_address_to_string (X)) +#define target_debug_print_enum_remove_bp_reason(X) \ + target_debug_do_print (plongest (X)) static void target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status) diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c index 288703373ea..57e7939b419 100644 --- a/gdb/target-delegates.c +++ b/gdb/target-delegates.c @@ -262,24 +262,26 @@ debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct b } static int -delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) +delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3) { self = self->beneath; - return self->to_remove_breakpoint (self, arg1, arg2); + return self->to_remove_breakpoint (self, arg1, arg2, arg3); } static int -debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) +debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3) { int result; fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname); - result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2); + result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2, arg3); fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname); target_debug_print_struct_target_ops_p (&debug_target); fputs_unfiltered (", ", gdb_stdlog); target_debug_print_struct_gdbarch_p (arg1); fputs_unfiltered (", ", gdb_stdlog); target_debug_print_struct_bp_target_info_p (arg2); + fputs_unfiltered (", ", gdb_stdlog); + target_debug_print_enum_remove_bp_reason (arg3); fputs_unfiltered (") = ", gdb_stdlog); target_debug_print_int (result); fputs_unfiltered ("\n", gdb_stdlog); diff --git a/gdb/target.c b/gdb/target.c index 5603d0193d7..13e3cdb50d3 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -2113,7 +2113,8 @@ target_insert_breakpoint (struct gdbarch *gdbarch, int target_remove_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { /* This is kind of a weird case to handle, but the permission might have been changed after breakpoints were inserted - in which case @@ -2126,7 +2127,7 @@ target_remove_breakpoint (struct gdbarch *gdbarch, } return current_target.to_remove_breakpoint (¤t_target, - gdbarch, bp_tgt); + gdbarch, bp_tgt, reason); } static void diff --git a/gdb/target.h b/gdb/target.h index 70913602603..9506e04ec9b 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -478,7 +478,8 @@ struct target_ops struct bp_target_info *) TARGET_DEFAULT_FUNC (memory_insert_breakpoint); int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *, - struct bp_target_info *) + struct bp_target_info *, + enum remove_bp_reason) TARGET_DEFAULT_FUNC (memory_remove_breakpoint); /* Returns true if the target stopped because it executed a @@ -1507,7 +1508,8 @@ extern int target_insert_breakpoint (struct gdbarch *gdbarch, machine. Result is 0 for success, non-zero for error. */ extern int target_remove_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt); + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason); /* Returns true if the terminal settings of the inferior are in effect. */ @@ -2373,7 +2375,8 @@ extern struct target_section_table *target_get_section_table /* From mem-break.c */ extern int memory_remove_breakpoint (struct target_ops *, struct gdbarch *, - struct bp_target_info *); + struct bp_target_info *, + enum remove_bp_reason); extern int memory_insert_breakpoint (struct target_ops *, struct gdbarch *, struct bp_target_info *); -- cgit v1.2.1