gdb/annotate.c

   1 /* Annotation routines for GDB.
   2    Copyright (C) 1986, 1989-1992, 1994-1996, 1998-2000, 2007-2012 Free
   3    Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "annotate.h"
  22 #include "value.h"
  23 #include "target.h"
  24 #include "gdbtypes.h"
  25 #include "breakpoint.h"
  26 #include "observer.h"
  27 \f
  28
  29 /* Prototypes for local functions.  */
  30
  31 extern void _initialize_annotate (void);
  32
  33 static void print_value_flags (struct type *);
  34
  35 static void breakpoint_changed (struct breakpoint *b);
  36
  37
  38 void (*deprecated_annotate_signalled_hook) (void);
  39 void (*deprecated_annotate_signal_hook) (void);
  40
  41 static int ignore_count_changed = 0;
  42
  43 static void
  44 print_value_flags (struct type *t)
  45 {
  46   if (can_dereference (t))
  47     printf_filtered (("*"));
  48   else
  49     printf_filtered (("-"));
  50 }
  51 \f
  52 void
  53 annotate_breakpoints_changed (void)
  54 {
  55   if (annotation_level == 2)
  56     {
  57       target_terminal_ours ();
  58       printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
  59       if (ignore_count_changed)
  60         ignore_count_changed = 0;   /* Avoid multiple break annotations.  */
  61     }
  62 }
  63
  64 /* The GUI needs to be informed of ignore_count changes, but we don't
  65    want to provide successive multiple breakpoints-invalid messages
  66    that are all caused by the fact that the ignore count is changing
  67    (which could keep the GUI very busy).  One is enough, after the
  68    target actually "stops".  */
  69
  70 void
  71 annotate_ignore_count_change (void)
  72 {
  73   if (annotation_level > 1)
  74     ignore_count_changed = 1;
  75 }
  76
  77 void
  78 annotate_breakpoint (int num)
  79 {
  80   if (annotation_level > 1)
  81     printf_filtered (("\n\032\032breakpoint %d\n"), num);
  82 }
  83
  84 void
  85 annotate_catchpoint (int num)
  86 {
  87   if (annotation_level > 1)
  88     printf_filtered (("\n\032\032catchpoint %d\n"), num);
  89 }
  90
  91 void
  92 annotate_watchpoint (int num)
  93 {
  94   if (annotation_level > 1)
  95     printf_filtered (("\n\032\032watchpoint %d\n"), num);
  96 }
  97
  98 void
  99 annotate_starting (void)
 100 {
 101   if (annotation_level > 1)
 102     printf_filtered (("\n\032\032starting\n"));
 103 }
 104
 105 void
 106 annotate_stopped (void)
 107 {
 108   if (annotation_level > 1)
 109     printf_filtered (("\n\032\032stopped\n"));
 110   if (annotation_level > 1 && ignore_count_changed)
 111     {
 112       ignore_count_changed = 0;
 113       annotate_breakpoints_changed ();
 114     }
 115 }
 116
 117 void
 118 annotate_exited (int exitstatus)
 119 {
 120   if (annotation_level > 1)
 121     printf_filtered (("\n\032\032exited %d\n"), exitstatus);
 122 }
 123
 124 void
 125 annotate_signalled (void)
 126 {
 127   if (deprecated_annotate_signalled_hook)
 128     deprecated_annotate_signalled_hook ();
 129
 130   if (annotation_level > 1)
 131     printf_filtered (("\n\032\032signalled\n"));
 132 }
 133
 134 void
 135 annotate_signal_name (void)
 136 {
 137   if (annotation_level == 2)
 138     printf_filtered (("\n\032\032signal-name\n"));
 139 }
 140
 141 void
 142 annotate_signal_name_end (void)
 143 {
 144   if (annotation_level == 2)
 145     printf_filtered (("\n\032\032signal-name-end\n"));
 146 }
 147
 148 void
 149 annotate_signal_string (void)
 150 {
 151   if (annotation_level == 2)
 152     printf_filtered (("\n\032\032signal-string\n"));
 153 }
 154
 155 void
 156 annotate_signal_string_end (void)
 157 {
 158   if (annotation_level == 2)
 159     printf_filtered (("\n\032\032signal-string-end\n"));
 160 }
 161
 162 void
 163 annotate_signal (void)
 164 {
 165   if (deprecated_annotate_signal_hook)
 166     deprecated_annotate_signal_hook ();
 167
 168   if (annotation_level > 1)
 169     printf_filtered (("\n\032\032signal\n"));
 170 }
 171 \f
 172 void
 173 annotate_breakpoints_headers (void)
 174 {
 175   if (annotation_level == 2)
 176     printf_filtered (("\n\032\032breakpoints-headers\n"));
 177 }
 178
 179 void
 180 annotate_field (int num)
 181 {
 182   if (annotation_level == 2)
 183     printf_filtered (("\n\032\032field %d\n"), num);
 184 }
 185
 186 void
 187 annotate_breakpoints_table (void)
 188 {
 189   if (annotation_level == 2)
 190     printf_filtered (("\n\032\032breakpoints-table\n"));
 191 }
 192
 193 void
 194 annotate_record (void)
 195 {
 196   if (annotation_level == 2)
 197     printf_filtered (("\n\032\032record\n"));
 198 }
 199
 200 void
 201 annotate_breakpoints_table_end (void)
 202 {
 203   if (annotation_level == 2)
 204     printf_filtered (("\n\032\032breakpoints-table-end\n"));
 205 }
 206
 207 void
 208 annotate_frames_invalid (void)
 209 {
 210   if (annotation_level == 2)
 211     {
 212       target_terminal_ours ();
 213       printf_unfiltered (("\n\032\032frames-invalid\n"));
 214     }
 215 }
 216
 217 void
 218 annotate_new_thread (void)
 219 {
 220   if (annotation_level > 1)
 221     {
 222       printf_unfiltered (("\n\032\032new-thread\n"));
 223     }
 224 }
 225
 226 void
 227 annotate_thread_changed (void)
 228 {
 229   if (annotation_level > 1)
 230     {
 231       printf_unfiltered (("\n\032\032thread-changed\n"));
 232     }
 233 }
 234
 235 void
 236 annotate_field_begin (struct type *type)
 237 {
 238   if (annotation_level == 2)
 239     {
 240       printf_filtered (("\n\032\032field-begin "));
 241       print_value_flags (type);
 242       printf_filtered (("\n"));
 243     }
 244 }
 245
 246 void
 247 annotate_field_name_end (void)
 248 {
 249   if (annotation_level == 2)
 250     printf_filtered (("\n\032\032field-name-end\n"));
 251 }
 252
 253 void
 254 annotate_field_value (void)
 255 {
 256   if (annotation_level == 2)
 257     printf_filtered (("\n\032\032field-value\n"));
 258 }
 259
 260 void
 261 annotate_field_end (void)
 262 {
 263   if (annotation_level == 2)
 264     printf_filtered (("\n\032\032field-end\n"));
 265 }
 266 \f
 267 void
 268 annotate_quit (void)
 269 {
 270   if (annotation_level > 1)
 271     printf_filtered (("\n\032\032quit\n"));
 272 }
 273
 274 void
 275 annotate_error (void)
 276 {
 277   if (annotation_level > 1)
 278     printf_filtered (("\n\032\032error\n"));
 279 }
 280
 281 void
 282 annotate_error_begin (void)
 283 {
 284   if (annotation_level > 1)
 285     fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
 286 }
 287
 288 void
 289 annotate_value_history_begin (int histindex, struct type *type)
 290 {
 291   if (annotation_level == 2)
 292     {
 293       printf_filtered (("\n\032\032value-history-begin %d "), histindex);
 294       print_value_flags (type);
 295       printf_filtered (("\n"));
 296     }
 297 }
 298
 299 void
 300 annotate_value_begin (struct type *type)
 301 {
 302   if (annotation_level == 2)
 303     {
 304       printf_filtered (("\n\032\032value-begin "));
 305       print_value_flags (type);
 306       printf_filtered (("\n"));
 307     }
 308 }
 309
 310 void
 311 annotate_value_history_value (void)
 312 {
 313   if (annotation_level == 2)
 314     printf_filtered (("\n\032\032value-history-value\n"));
 315 }
 316
 317 void
 318 annotate_value_history_end (void)
 319 {
 320   if (annotation_level == 2)
 321     printf_filtered (("\n\032\032value-history-end\n"));
 322 }
 323
 324 void
 325 annotate_value_end (void)
 326 {
 327   if (annotation_level == 2)
 328     printf_filtered (("\n\032\032value-end\n"));
 329 }
 330
 331 void
 332 annotate_display_begin (void)
 333 {
 334   if (annotation_level == 2)
 335     printf_filtered (("\n\032\032display-begin\n"));
 336 }
 337
 338 void
 339 annotate_display_number_end (void)
 340 {
 341   if (annotation_level == 2)
 342     printf_filtered (("\n\032\032display-number-end\n"));
 343 }
 344
 345 void
 346 annotate_display_format (void)
 347 {
 348   if (annotation_level == 2)
 349     printf_filtered (("\n\032\032display-format\n"));
 350 }
 351
 352 void
 353 annotate_display_expression (void)
 354 {
 355   if (annotation_level == 2)
 356     printf_filtered (("\n\032\032display-expression\n"));
 357 }
 358
 359 void
 360 annotate_display_expression_end (void)
 361 {
 362   if (annotation_level == 2)
 363     printf_filtered (("\n\032\032display-expression-end\n"));
 364 }
 365
 366 void
 367 annotate_display_value (void)
 368 {
 369   if (annotation_level == 2)
 370     printf_filtered (("\n\032\032display-value\n"));
 371 }
 372
 373 void
 374 annotate_display_end (void)
 375 {
 376   if (annotation_level == 2)
 377     printf_filtered (("\n\032\032display-end\n"));
 378 }
 379
 380 void
 381 annotate_arg_begin (void)
 382 {
 383   if (annotation_level == 2)
 384     printf_filtered (("\n\032\032arg-begin\n"));
 385 }
 386
 387 void
 388 annotate_arg_name_end (void)
 389 {
 390   if (annotation_level == 2)
 391     printf_filtered (("\n\032\032arg-name-end\n"));
 392 }
 393
 394 void
 395 annotate_arg_value (struct type *type)
 396 {
 397   if (annotation_level == 2)
 398     {
 399       printf_filtered (("\n\032\032arg-value "));
 400       print_value_flags (type);
 401       printf_filtered (("\n"));
 402     }
 403 }
 404
 405 void
 406 annotate_arg_end (void)
 407 {
 408   if (annotation_level == 2)
 409     printf_filtered (("\n\032\032arg-end\n"));
 410 }
 411
 412 void
 413 annotate_source (char *filename, int line, int character, int mid,
 414                  struct gdbarch *gdbarch, CORE_ADDR pc)
 415 {
 416   if (annotation_level > 1)
 417     printf_filtered (("\n\032\032source "));
 418   else
 419     printf_filtered (("\032\032"));
 420
 421   printf_filtered (("%s:%d:%d:%s:%s\n"), filename, line, character,
 422                    mid ? "middle" : "beg", paddress (gdbarch, pc));
 423 }
 424
 425 void
 426 annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc)
 427 {
 428   if (annotation_level > 1)
 429     printf_filtered (("\n\032\032frame-begin %d %s\n"),
 430                      level, paddress (gdbarch, pc));
 431 }
 432
 433 void
 434 annotate_function_call (void)
 435 {
 436   if (annotation_level == 2)
 437     printf_filtered (("\n\032\032function-call\n"));
 438 }
 439
 440 void
 441 annotate_signal_handler_caller (void)
 442 {
 443   if (annotation_level == 2)
 444     printf_filtered (("\n\032\032signal-handler-caller\n"));
 445 }
 446
 447 void
 448 annotate_frame_address (void)
 449 {
 450   if (annotation_level == 2)
 451     printf_filtered (("\n\032\032frame-address\n"));
 452 }
 453
 454 void
 455 annotate_frame_address_end (void)
 456 {
 457   if (annotation_level == 2)
 458     printf_filtered (("\n\032\032frame-address-end\n"));
 459 }
 460
 461 void
 462 annotate_frame_function_name (void)
 463 {
 464   if (annotation_level == 2)
 465     printf_filtered (("\n\032\032frame-function-name\n"));
 466 }
 467
 468 void
 469 annotate_frame_args (void)
 470 {
 471   if (annotation_level == 2)
 472     printf_filtered (("\n\032\032frame-args\n"));
 473 }
 474
 475 void
 476 annotate_frame_source_begin (void)
 477 {
 478   if (annotation_level == 2)
 479     printf_filtered (("\n\032\032frame-source-begin\n"));
 480 }
 481
 482 void
 483 annotate_frame_source_file (void)
 484 {
 485   if (annotation_level == 2)
 486     printf_filtered (("\n\032\032frame-source-file\n"));
 487 }
 488
 489 void
 490 annotate_frame_source_file_end (void)
 491 {
 492   if (annotation_level == 2)
 493     printf_filtered (("\n\032\032frame-source-file-end\n"));
 494 }
 495
 496 void
 497 annotate_frame_source_line (void)
 498 {
 499   if (annotation_level == 2)
 500     printf_filtered (("\n\032\032frame-source-line\n"));
 501 }
 502
 503 void
 504 annotate_frame_source_end (void)
 505 {
 506   if (annotation_level == 2)
 507     printf_filtered (("\n\032\032frame-source-end\n"));
 508 }
 509
 510 void
 511 annotate_frame_where (void)
 512 {
 513   if (annotation_level == 2)
 514     printf_filtered (("\n\032\032frame-where\n"));
 515 }
 516
 517 void
 518 annotate_frame_end (void)
 519 {
 520   if (annotation_level == 2)
 521     printf_filtered (("\n\032\032frame-end\n"));
 522 }
 523 \f
 524 void
 525 annotate_array_section_begin (int idx, struct type *elttype)
 526 {
 527   if (annotation_level == 2)
 528     {
 529       printf_filtered (("\n\032\032array-section-begin %d "), idx);
 530       print_value_flags (elttype);
 531       printf_filtered (("\n"));
 532     }
 533 }
 534
 535 void
 536 annotate_elt_rep (unsigned int repcount)
 537 {
 538   if (annotation_level == 2)
 539     printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
 540 }
 541
 542 void
 543 annotate_elt_rep_end (void)
 544 {
 545   if (annotation_level == 2)
 546     printf_filtered (("\n\032\032elt-rep-end\n"));
 547 }
 548
 549 void
 550 annotate_elt (void)
 551 {
 552   if (annotation_level == 2)
 553     printf_filtered (("\n\032\032elt\n"));
 554 }
 555
 556 void
 557 annotate_array_section_end (void)
 558 {
 559   if (annotation_level == 2)
 560     printf_filtered (("\n\032\032array-section-end\n"));
 561 }
 562
 563 static void
 564 breakpoint_changed (struct breakpoint *b)
 565 {
 566   annotate_breakpoints_changed ();
 567 }
 568
 569 void
 570 _initialize_annotate (void)
 571 {
 572   if (annotation_level == 2)
 573     {
 574       observer_attach_breakpoint_deleted (breakpoint_changed);
 575       observer_attach_breakpoint_modified (breakpoint_changed);
 576     }
 577 }