gdb/annotate.c

   1 /* Annotation routines for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999,
   3    2000, 2007, 2008, 2009 Free 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 (int);
  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 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       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, CORE_ADDR pc)
 414 {
 415   if (annotation_level > 1)
 416     printf_filtered (("\n\032\032source "));
 417   else
 418     printf_filtered (("\032\032"));
 419
 420   printf_filtered (("%s:%d:%d:%s:%s\n"), filename, line, character,
 421                    mid ? "middle" : "beg", paddress (pc));
 422 }
 423
 424 void
 425 annotate_frame_begin (int level, CORE_ADDR pc)
 426 {
 427   if (annotation_level > 1)
 428     printf_filtered (("\n\032\032frame-begin %d %s\n"), level, paddress (pc));
 429 }
 430
 431 void
 432 annotate_function_call (void)
 433 {
 434   if (annotation_level == 2)
 435     printf_filtered (("\n\032\032function-call\n"));
 436 }
 437
 438 void
 439 annotate_signal_handler_caller (void)
 440 {
 441   if (annotation_level == 2)
 442     printf_filtered (("\n\032\032signal-handler-caller\n"));
 443 }
 444
 445 void
 446 annotate_frame_address (void)
 447 {
 448   if (annotation_level == 2)
 449     printf_filtered (("\n\032\032frame-address\n"));
 450 }
 451
 452 void
 453 annotate_frame_address_end (void)
 454 {
 455   if (annotation_level == 2)
 456     printf_filtered (("\n\032\032frame-address-end\n"));
 457 }
 458
 459 void
 460 annotate_frame_function_name (void)
 461 {
 462   if (annotation_level == 2)
 463     printf_filtered (("\n\032\032frame-function-name\n"));
 464 }
 465
 466 void
 467 annotate_frame_args (void)
 468 {
 469   if (annotation_level == 2)
 470     printf_filtered (("\n\032\032frame-args\n"));
 471 }
 472
 473 void
 474 annotate_frame_source_begin (void)
 475 {
 476   if (annotation_level == 2)
 477     printf_filtered (("\n\032\032frame-source-begin\n"));
 478 }
 479
 480 void
 481 annotate_frame_source_file (void)
 482 {
 483   if (annotation_level == 2)
 484     printf_filtered (("\n\032\032frame-source-file\n"));
 485 }
 486
 487 void
 488 annotate_frame_source_file_end (void)
 489 {
 490   if (annotation_level == 2)
 491     printf_filtered (("\n\032\032frame-source-file-end\n"));
 492 }
 493
 494 void
 495 annotate_frame_source_line (void)
 496 {
 497   if (annotation_level == 2)
 498     printf_filtered (("\n\032\032frame-source-line\n"));
 499 }
 500
 501 void
 502 annotate_frame_source_end (void)
 503 {
 504   if (annotation_level == 2)
 505     printf_filtered (("\n\032\032frame-source-end\n"));
 506 }
 507
 508 void
 509 annotate_frame_where (void)
 510 {
 511   if (annotation_level == 2)
 512     printf_filtered (("\n\032\032frame-where\n"));
 513 }
 514
 515 void
 516 annotate_frame_end (void)
 517 {
 518   if (annotation_level == 2)
 519     printf_filtered (("\n\032\032frame-end\n"));
 520 }
 521 \f
 522 void
 523 annotate_array_section_begin (int index, struct type *elttype)
 524 {
 525   if (annotation_level == 2)
 526     {
 527       printf_filtered (("\n\032\032array-section-begin %d "), index);
 528       print_value_flags (elttype);
 529       printf_filtered (("\n"));
 530     }
 531 }
 532
 533 void
 534 annotate_elt_rep (unsigned int repcount)
 535 {
 536   if (annotation_level == 2)
 537     printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
 538 }
 539
 540 void
 541 annotate_elt_rep_end (void)
 542 {
 543   if (annotation_level == 2)
 544     printf_filtered (("\n\032\032elt-rep-end\n"));
 545 }
 546
 547 void
 548 annotate_elt (void)
 549 {
 550   if (annotation_level == 2)
 551     printf_filtered (("\n\032\032elt\n"));
 552 }
 553
 554 void
 555 annotate_array_section_end (void)
 556 {
 557   if (annotation_level == 2)
 558     printf_filtered (("\n\032\032array-section-end\n"));
 559 }
 560
 561 static void
 562 breakpoint_changed (int bpno)
 563 {
 564   breakpoints_changed ();
 565 }
 566
 567 void
 568 _initialize_annotate (void)
 569 {
 570   if (annotation_level == 2)
 571     {
 572       observer_attach_breakpoint_deleted (breakpoint_changed);
 573       observer_attach_breakpoint_modified (breakpoint_changed);
 574     }
 575 }