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