mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
9c97429fb1
observer_notify_breakpoints_changed calls. All, except the
init_raw_breakpoint one. But that one is actually wrong. The
breakpoint is being constructed at that point, and hasn't been placed
on the breakpoint chain yet. It would be better placed in
install_breakpoint, and I actually started out that way. But once the
annotate_breakpoints_changed are parallel to the observer calls, we
can fully move annotations to observers too.
One issue is that this changes the order of annotations a bit.
Before, we'd emit the annotation, and after call "mention()" on the
breakpoint (which prints the breakpoint number, etc.). But, we call
the observers _after_ mention is called, so the annotation output will
change a little:
void
install_breakpoint (int internal, struct breakpoint *b, int update_gll)
{
add_to_breakpoint_chain (b);
set_breakpoint_number (internal, b);
if (is_tracepoint (b))
set_tracepoint_count (breakpoint_count);
if (!internal)
mention (b);
observer_notify_breakpoint_created (b);
if (update_gll)
update_global_location_list (1);
}
I believe this order doesn't really matter (the frontend needs to wait
for the prompt anyway), so I just adjust the expected output in the
tests. Emacs in annotations mode doesn't seem to complain. Couple
that with the previous patch that suppressed duplicated annotations,
and, the fact that some annotations calls were actually missing (were
we do have observer calls), more changes to the tests are needed
anyway.
Tested on x86_64 Fedora 17.
gdb/
2013-01-22 Pedro Alves <palves@redhat.com>
* annotate.c (annotate_breakpoints_changed): Rename to ...
(annotate_breakpoints_invalid): ... this. Make static.
(breakpoint_changed): Adjust.
(_initialize_annotate): Always install the observers. Install a
"breakpoint_created" observer.
* annotate.h (annotate_breakpoints_changed): Delete declaration.
* breakpoint.c (set_breakpoint_condition)
(breakpoint_set_commands, do_map_commands_command)
(init_raw_breakpoint, clear_command, set_ignore_count)
(enable_breakpoint_disp): No longer call
annotate_breakpoints_changed.
gdb/testsuite/
2013-01-22 Pedro Alves <palves@redhat.com>
* gdb.base/annota1.exp (breakpoints_invalid): New variable.
Adjust tests to breakpoints-invalid changes.
* gdb.cp/annota2.exp (breakpoints_invalid, frames_invalid): New
variables.
Adjust tests to breakpoints-invalid changes.
588 lines
12 KiB
C
588 lines
12 KiB
C
/* Annotation routines for GDB.
|
||
Copyright (C) 1986-2013 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "annotate.h"
|
||
#include "value.h"
|
||
#include "target.h"
|
||
#include "gdbtypes.h"
|
||
#include "breakpoint.h"
|
||
#include "observer.h"
|
||
#include "inferior.h"
|
||
|
||
|
||
/* Prototypes for local functions. */
|
||
|
||
extern void _initialize_annotate (void);
|
||
|
||
static void print_value_flags (struct type *);
|
||
|
||
static void breakpoint_changed (struct breakpoint *b);
|
||
|
||
|
||
void (*deprecated_annotate_signalled_hook) (void);
|
||
void (*deprecated_annotate_signal_hook) (void);
|
||
|
||
/* 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)
|
||
{
|
||
if (can_dereference (t))
|
||
printf_filtered (("*"));
|
||
else
|
||
printf_filtered (("-"));
|
||
}
|
||
|
||
static void
|
||
annotate_breakpoints_invalid (void)
|
||
{
|
||
if (annotation_level == 2
|
||
&& (!breakpoints_invalid_emitted
|
||
|| async_background_execution_p ()))
|
||
{
|
||
target_terminal_ours ();
|
||
printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
|
||
breakpoints_invalid_emitted = 1;
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_breakpoint (int num)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032breakpoint %d\n"), num);
|
||
}
|
||
|
||
void
|
||
annotate_catchpoint (int num)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032catchpoint %d\n"), num);
|
||
}
|
||
|
||
void
|
||
annotate_watchpoint (int num)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032watchpoint %d\n"), num);
|
||
}
|
||
|
||
void
|
||
annotate_starting (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032starting\n"));
|
||
}
|
||
|
||
void
|
||
annotate_stopped (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032stopped\n"));
|
||
}
|
||
|
||
void
|
||
annotate_exited (int exitstatus)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032exited %d\n"), exitstatus);
|
||
}
|
||
|
||
void
|
||
annotate_signalled (void)
|
||
{
|
||
if (deprecated_annotate_signalled_hook)
|
||
deprecated_annotate_signalled_hook ();
|
||
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032signalled\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal_name (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032signal-name\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal_name_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032signal-name-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal_string (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032signal-string\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal_string_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032signal-string-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal (void)
|
||
{
|
||
if (deprecated_annotate_signal_hook)
|
||
deprecated_annotate_signal_hook ();
|
||
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032signal\n"));
|
||
}
|
||
|
||
void
|
||
annotate_breakpoints_headers (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032breakpoints-headers\n"));
|
||
}
|
||
|
||
void
|
||
annotate_field (int num)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032field %d\n"), num);
|
||
}
|
||
|
||
void
|
||
annotate_breakpoints_table (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032breakpoints-table\n"));
|
||
}
|
||
|
||
void
|
||
annotate_record (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032record\n"));
|
||
}
|
||
|
||
void
|
||
annotate_breakpoints_table_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032breakpoints-table-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frames_invalid (void)
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_new_thread (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
{
|
||
printf_unfiltered (("\n\032\032new-thread\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_thread_changed (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
{
|
||
printf_unfiltered (("\n\032\032thread-changed\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_field_begin (struct type *type)
|
||
{
|
||
if (annotation_level == 2)
|
||
{
|
||
printf_filtered (("\n\032\032field-begin "));
|
||
print_value_flags (type);
|
||
printf_filtered (("\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_field_name_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032field-name-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_field_value (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032field-value\n"));
|
||
}
|
||
|
||
void
|
||
annotate_field_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032field-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_quit (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032quit\n"));
|
||
}
|
||
|
||
void
|
||
annotate_error (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032error\n"));
|
||
}
|
||
|
||
void
|
||
annotate_error_begin (void)
|
||
{
|
||
if (annotation_level > 1)
|
||
fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
|
||
}
|
||
|
||
void
|
||
annotate_value_history_begin (int histindex, struct type *type)
|
||
{
|
||
if (annotation_level == 2)
|
||
{
|
||
printf_filtered (("\n\032\032value-history-begin %d "), histindex);
|
||
print_value_flags (type);
|
||
printf_filtered (("\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_value_begin (struct type *type)
|
||
{
|
||
if (annotation_level == 2)
|
||
{
|
||
printf_filtered (("\n\032\032value-begin "));
|
||
print_value_flags (type);
|
||
printf_filtered (("\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_value_history_value (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032value-history-value\n"));
|
||
}
|
||
|
||
void
|
||
annotate_value_history_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032value-history-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_value_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032value-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_begin (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-begin\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_number_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-number-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_format (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-format\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_expression (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-expression\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_expression_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-expression-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_value (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-value\n"));
|
||
}
|
||
|
||
void
|
||
annotate_display_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032display-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_arg_begin (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032arg-begin\n"));
|
||
}
|
||
|
||
void
|
||
annotate_arg_name_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032arg-name-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_arg_value (struct type *type)
|
||
{
|
||
if (annotation_level == 2)
|
||
{
|
||
printf_filtered (("\n\032\032arg-value "));
|
||
print_value_flags (type);
|
||
printf_filtered (("\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_arg_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032arg-end\n"));
|
||
}
|
||
|
||
void
|
||
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:%s\n"), filename, line, character,
|
||
mid ? "middle" : "beg", paddress (gdbarch, pc));
|
||
}
|
||
|
||
void
|
||
annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc)
|
||
{
|
||
if (annotation_level > 1)
|
||
printf_filtered (("\n\032\032frame-begin %d %s\n"),
|
||
level, paddress (gdbarch, pc));
|
||
}
|
||
|
||
void
|
||
annotate_function_call (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032function-call\n"));
|
||
}
|
||
|
||
void
|
||
annotate_signal_handler_caller (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032signal-handler-caller\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_address (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-address\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_address_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-address-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_function_name (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-function-name\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_args (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-args\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_source_begin (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-source-begin\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_source_file (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-source-file\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_source_file_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-source-file-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_source_line (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-source-line\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_source_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-source-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_where (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-where\n"));
|
||
}
|
||
|
||
void
|
||
annotate_frame_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032frame-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_array_section_begin (int idx, struct type *elttype)
|
||
{
|
||
if (annotation_level == 2)
|
||
{
|
||
printf_filtered (("\n\032\032array-section-begin %d "), idx);
|
||
print_value_flags (elttype);
|
||
printf_filtered (("\n"));
|
||
}
|
||
}
|
||
|
||
void
|
||
annotate_elt_rep (unsigned int repcount)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
|
||
}
|
||
|
||
void
|
||
annotate_elt_rep_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032elt-rep-end\n"));
|
||
}
|
||
|
||
void
|
||
annotate_elt (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
printf_filtered (("\n\032\032elt\n"));
|
||
}
|
||
|
||
void
|
||
annotate_array_section_end (void)
|
||
{
|
||
if (annotation_level == 2)
|
||
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)
|
||
{
|
||
annotate_breakpoints_invalid ();
|
||
}
|
||
|
||
void
|
||
_initialize_annotate (void)
|
||
{
|
||
observer_attach_breakpoint_created (breakpoint_changed);
|
||
observer_attach_breakpoint_deleted (breakpoint_changed);
|
||
observer_attach_breakpoint_modified (breakpoint_changed);
|
||
}
|