From 187d10dd19b822ba6e5470f1bd67fc94f5b48a86 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Tue, 22 Jan 2013 20:08:30 +0000 Subject: [PATCH] There's code in annotate.c and breakpoint.c that is supposed to suppress multiple breakpoints-invalid annotations when the ignore count of a breakpoint changes, up until the target actually stops. But, the code is bogus: void annotate_breakpoints_changed (void) { if (annotation_level == 2) { target_terminal_ours (); printf_unfiltered (("\n\032\032breakpoints-invalid\n")); if (ignore_count_changed) ignore_count_changed = 0; /* Avoid multiple break annotations. */ } } The "ignore_count_changed" flag isn't actually guarding the output of the annotation at all. It would have been better written something like: void annotate_breakpoints_changed (void) { if (annotation_level == 2 && !ignore_count_changed) { target_terminal_ours (); printf_unfiltered (("\n\032\032breakpoints-invalid\n")); ignore_count_changed = 0; /* Avoid multiple break annotations. */ } } but, it wasn't. AFAICS, that goes all the way back to the original patch'es submission and check in, at . I looked a tar of HP's wdb from 1999, and even though that contains local changes in the annotate code, this suppression seems borked there too to me. The original patch added a test to supposedly exercise this suppression, but, it actually doesn't. It merely tests that "breakpoints-invalid" is output after "stopped", but doesn't check whether the duplicates supression actually works (IOW, check that only _one_ annotation is seen). I was going to simply delete the tests too, but a following patch will eliminate the duplicates in a different way (which I needed for a different reason), so instead, I'm making the tests actually fail if a duplicate annotation is seen. Worry not, the test doesn't actually fail! The reason is that breakpoint.c does: else if (b->ignore_count > 0) { b->ignore_count--; annotate_ignore_count_change (); bs->stop = 0; /* Increase the hit count even though we don't stop. */ ++(b->hit_count); observer_notify_breakpoint_modified (b); } where the annotate_ignore_count_change call is meant to inform the "breakpoint_modified" annotation observer to ignore the notification. All sounds good. But, the trouble is that nowadays annotate.c only installs the observers if GDB is started with annotations enabled with a command line option (gdb --annotate=2): void _initialize_annotate (void) { if (annotation_level == 2) { observer_attach_breakpoint_deleted (breakpoint_changed); observer_attach_breakpoint_modified (breakpoint_changed); } } and annota1.exp, to enable annotations, starts GDB normally, and afterwards does "set annotate 2", so the observers aren't installed when annota1.exp is run, and therefore changing the ignore count isn't triggering any annotation at all... gdb/ 2013-01-22 Pedro Alves * annotate.c (ignore_count_changed): Delete. (annotate_breakpoints_changed): Don't clear ignore_count_changed. (annotate_ignore_count_change): Delete. (annotate_stopped): Don't emit a delayed breakpoints-changed annotation. * annotate.h (annotate_ignore_count_change): Delete. * breakpoint.c (bpstat_check_breakpoint_conditions): Don't call annotate_ignore_count_change. gdb/testsuite/ 2013-01-22 Pedro Alves * gdb.base/annota1.exp (annotate ignore count change): Add expected output for failure case. --- gdb/ChangeLog | 11 +++++++++++ gdb/annotate.c | 22 ---------------------- gdb/annotate.h | 1 - gdb/breakpoint.c | 1 - gdb/testsuite/ChangeLog | 5 +++++ gdb/testsuite/gdb.base/annota1.exp | 5 ++++- 6 files changed, 20 insertions(+), 25 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index eb02b37..fd4e37f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2013-01-22 Pedro Alves + + * annotate.c (ignore_count_changed): Delete. + (annotate_breakpoints_changed): Don't clear ignore_count_changed. + (annotate_ignore_count_change): Delete. + (annotate_stopped): Don't emit a delayed breakpoints-changed + annotation. + * annotate.h (annotate_ignore_count_change): Delete. + * breakpoint.c (bpstat_check_breakpoint_conditions): Don't call + annotate_ignore_count_change. + 2013-01-22 Tom Tromey * dwarf2loc.c (dwarf2_compile_expr_to_ax) : Only diff --git a/gdb/annotate.c b/gdb/annotate.c index 1919467..25f76598 100644 --- a/gdb/annotate.c +++ b/gdb/annotate.c @@ -37,8 +37,6 @@ static void breakpoint_changed (struct breakpoint *b); void (*deprecated_annotate_signalled_hook) (void); void (*deprecated_annotate_signal_hook) (void); -static int ignore_count_changed = 0; - static void print_value_flags (struct type *t) { @@ -55,24 +53,9 @@ annotate_breakpoints_changed (void) { target_terminal_ours (); printf_unfiltered (("\n\032\032breakpoints-invalid\n")); - if (ignore_count_changed) - ignore_count_changed = 0; /* Avoid multiple break annotations. */ } } -/* The GUI needs to be informed of ignore_count changes, but we don't - want to provide successive multiple breakpoints-invalid messages - that are all caused by the fact that the ignore count is changing - (which could keep the GUI very busy). One is enough, after the - target actually "stops". */ - -void -annotate_ignore_count_change (void) -{ - if (annotation_level > 1) - ignore_count_changed = 1; -} - void annotate_breakpoint (int num) { @@ -106,11 +89,6 @@ annotate_stopped (void) { if (annotation_level > 1) printf_filtered (("\n\032\032stopped\n")); - if (annotation_level > 1 && ignore_count_changed) - { - ignore_count_changed = 0; - annotate_breakpoints_changed (); - } } void diff --git a/gdb/annotate.h b/gdb/annotate.h index 2ea465a..ea8ad15 100644 --- a/gdb/annotate.h +++ b/gdb/annotate.h @@ -21,7 +21,6 @@ extern void annotate_breakpoints_changed (void); -extern void annotate_ignore_count_change (void); extern void annotate_breakpoint (int); extern void annotate_catchpoint (int); extern void annotate_watchpoint (int); diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index fd4132f..35848b4 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -5137,7 +5137,6 @@ bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid) else if (b->ignore_count > 0) { b->ignore_count--; - annotate_ignore_count_change (); bs->stop = 0; /* Increase the hit count even though we don't stop. */ ++(b->hit_count); diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 1010c99..5d3ed12 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2013-01-22 Pedro Alves + + * gdb.base/annota1.exp (annotate ignore count change): Add + expected output for failure case. + 2013-01-22 Tom Tromey * gdb.gdb/selftest.exp (do_steps_and_nexts): Handle bfd_init diff --git a/gdb/testsuite/gdb.base/annota1.exp b/gdb/testsuite/gdb.base/annota1.exp index 89fbd94..776738a 100644 --- a/gdb/testsuite/gdb.base/annota1.exp +++ b/gdb/testsuite/gdb.base/annota1.exp @@ -365,7 +365,10 @@ gdb_test_multiple "ignore 5 4" "ignore 5 4" { } gdb_test_multiple "continue" "annotate ignore count change" { - -re ".*$srcfile:$value_inc_line:.*\032\032stopped\r\n\r\n\032\032breakpoints-invalid\r\n$gdb_prompt$" { + -re ".*breakpoints-invalid.*breakpoints-invalid.*$gdb_prompt$" { + fail "annotate ignore count change" + } + -re ".*$srcfile:$value_inc_line:.*\032\032stopped\r\n$gdb_prompt$" { pass "annotate ignore count change" } } -- 2.7.4