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
<http://sourceware.org/ml/gdb-patches/1999-q4/msg00106.html>.  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  <palves@redhat.com>

	* 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  <palves@redhat.com>

	* gdb.base/annota1.exp (annotate ignore count change): Add
	expected output for failure case.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index eb02b37..fd4e37f 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,14 @@
+2013-01-22  Pedro Alves  <palves@redhat.com>
+
+       * 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  <tromey@redhat.com>
 
        * dwarf2loc.c (dwarf2_compile_expr_to_ax) <DW_OP_fbreg>: Only

diff --git a/gdb/annotate.c b/gdb/annotate.c
index 1919467..25f7659 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2013-01-22  Pedro Alves  <palves@redhat.com>
+
+       * gdb.base/annota1.exp (annotate ignore count change): Add
+       expected output for failure case.
+
 2013-01-22  Tom Tromey  <tromey@redhat.com>
 
        * 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 (file)
--- 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"
     }
 }