X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fannotate.c;h=135573316c2a624c6cd23b5782847b82233a7523;hb=9f1b45b0da430a7a7abf9e54acbe6f2ef9d3a763;hp=9494ee0bedab1e19dc65c31c70a161566c984542;hpb=d17d49478f357f6c4956b4add384e7d41d6f650e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/annotate.c b/gdb/annotate.c index 9494ee0bed..135573316c 100644 --- a/gdb/annotate.c +++ b/gdb/annotate.c @@ -1,6 +1,5 @@ /* Annotation routines for GDB. - Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999, - 2000, 2007, 2008 Free Software Foundation, Inc. + Copyright (C) 1986-2014 Free Software Foundation, Inc. This file is part of GDB. @@ -23,23 +22,38 @@ #include "target.h" #include "gdbtypes.h" #include "breakpoint.h" +#include "observer.h" +#include "inferior.h" -/* Prototypes for local functions. */ +/* Prototypes for local functions. */ extern void _initialize_annotate (void); static void print_value_flags (struct type *); -static void breakpoint_changed (struct breakpoint *); +static void breakpoint_changed (struct breakpoint *b); + -void (*deprecated_annotate_starting_hook) (void); -void (*deprecated_annotate_stopped_hook) (void); void (*deprecated_annotate_signalled_hook) (void); void (*deprecated_annotate_signal_hook) (void); -void (*deprecated_annotate_exited_hook) (void); -static int ignore_count_changed = 0; +/* Booleans indicating whether we've emitted certain notifications. + Used to suppress useless repeated notifications until the next time + we're ready to accept more commands. Reset whenever a prompt is + displayed. */ +static int frames_invalid_emitted; +static int breakpoints_invalid_emitted; + +/* True if the target can async, and a synchronous execution command + is not in progress. If true, input is accepted, so don't suppress + annotations. */ + +static int +async_background_execution_p (void) +{ + return (target_can_async_p () && !sync_execution); +} static void print_value_flags (struct type *t) @@ -49,32 +63,20 @@ print_value_flags (struct type *t) else printf_filtered (("-")); } - -void -breakpoints_changed (void) + +static void +annotate_breakpoints_invalid (void) { - if (annotation_level == 2) + if (annotation_level == 2 + && (!breakpoints_invalid_emitted + || async_background_execution_p ())) { target_terminal_ours (); printf_unfiltered (("\n\032\032breakpoints-invalid\n")); - if (ignore_count_changed) - ignore_count_changed = 0; /* Avoid multiple break annotations. */ + breakpoints_invalid_emitted = 1; } } -/* 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) { @@ -99,45 +101,22 @@ annotate_watchpoint (int num) void annotate_starting (void) { - - if (deprecated_annotate_starting_hook) - deprecated_annotate_starting_hook (); - else - { - if (annotation_level > 1) - { - printf_filtered (("\n\032\032starting\n")); - } - } + if (annotation_level > 1) + printf_filtered (("\n\032\032starting\n")); } void annotate_stopped (void) { - if (deprecated_annotate_stopped_hook) - deprecated_annotate_stopped_hook (); - else - { - if (annotation_level > 1) - printf_filtered (("\n\032\032stopped\n")); - } - if (annotation_level > 1 && ignore_count_changed) - { - ignore_count_changed = 0; - breakpoints_changed (); - } + if (annotation_level > 1) + printf_filtered (("\n\032\032stopped\n")); } void annotate_exited (int exitstatus) { - if (deprecated_annotate_exited_hook) - deprecated_annotate_exited_hook (); - else - { - if (annotation_level > 1) - printf_filtered (("\n\032\032exited %d\n"), exitstatus); - } + if (annotation_level > 1) + printf_filtered (("\n\032\032exited %d\n"), exitstatus); } void @@ -226,10 +205,13 @@ annotate_breakpoints_table_end (void) void annotate_frames_invalid (void) { - if (annotation_level == 2) + if (annotation_level == 2 + && (!frames_invalid_emitted + || async_background_execution_p ())) { target_terminal_ours (); printf_unfiltered (("\n\032\032frames-invalid\n")); + frames_invalid_emitted = 1; } } @@ -242,6 +224,15 @@ annotate_new_thread (void) } } +void +annotate_thread_changed (void) +{ + if (annotation_level > 1) + { + printf_unfiltered (("\n\032\032thread-changed\n")); + } +} + void annotate_field_begin (struct type *type) { @@ -420,29 +411,24 @@ annotate_arg_end (void) } void -annotate_source (char *filename, int line, int character, int mid, CORE_ADDR pc) +annotate_source (char *filename, int line, int character, int mid, + struct gdbarch *gdbarch, CORE_ADDR pc) { if (annotation_level > 1) printf_filtered (("\n\032\032source ")); else printf_filtered (("\032\032")); - printf_filtered (("%s:%d:%d:%s:0x"), filename, - line, character, - mid ? "middle" : "beg"); - deprecated_print_address_numeric (pc, 0, gdb_stdout); - printf_filtered (("\n")); + printf_filtered (("%s:%d:%d:%s:%s\n"), filename, line, character, + mid ? "middle" : "beg", paddress (gdbarch, pc)); } void -annotate_frame_begin (int level, CORE_ADDR pc) +annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc) { if (annotation_level > 1) - { - printf_filtered (("\n\032\032frame-begin %d 0x"), level); - deprecated_print_address_numeric (pc, 0, gdb_stdout); - printf_filtered (("\n")); - } + printf_filtered (("\n\032\032frame-begin %d %s\n"), + level, paddress (gdbarch, pc)); } void @@ -537,11 +523,11 @@ annotate_frame_end (void) } void -annotate_array_section_begin (int index, struct type *elttype) +annotate_array_section_begin (int idx, struct type *elttype) { if (annotation_level == 2) { - printf_filtered (("\n\032\032array-section-begin %d "), index); + printf_filtered (("\n\032\032array-section-begin %d "), idx); print_value_flags (elttype); printf_filtered (("\n")); } @@ -575,18 +561,30 @@ annotate_array_section_end (void) printf_filtered (("\n\032\032array-section-end\n")); } +/* Called when GDB is about to display the prompt. Used to reset + annotation suppression whenever we're ready to accept new + frontend/user commands. */ + +void +annotate_display_prompt (void) +{ + frames_invalid_emitted = 0; + breakpoints_invalid_emitted = 0; +} + static void breakpoint_changed (struct breakpoint *b) { - breakpoints_changed (); + if (b->number <= 0) + return; + + annotate_breakpoints_invalid (); } void _initialize_annotate (void) { - if (annotation_level == 2) - { - deprecated_delete_breakpoint_hook = breakpoint_changed; - deprecated_modify_breakpoint_hook = breakpoint_changed; - } + observer_attach_breakpoint_created (breakpoint_changed); + observer_attach_breakpoint_deleted (breakpoint_changed); + observer_attach_breakpoint_modified (breakpoint_changed); }