gdb/annotate.c

   1 /* Annotation routines for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999,
   3    2000, 2007 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_field_begin (struct type *type)
 238 {
 239   if (annotation_level == 2)
 240     {
 241       printf_filtered (("\n\032\032field-begin "));
 242       print_value_flags (type);
 243       printf_filtered (("\n"));
 244     }
 245 }
 246
 247 void
 248 annotate_field_name_end (void)
 249 {
 250   if (annotation_level == 2)
 251     printf_filtered (("\n\032\032field-name-end\n"));
 252 }
 253
 254 void
 255 annotate_field_value (void)
 256 {
 257   if (annotation_level == 2)
 258     printf_filtered (("\n\032\032field-value\n"));
 259 }
 260
 261 void
 262 annotate_field_end (void)
 263 {
 264   if (annotation_level == 2)
 265     printf_filtered (("\n\032\032field-end\n"));
 266 }
 267 \f
 268 void
 269 annotate_quit (void)
 270 {
 271   if (annotation_level > 1)
 272     printf_filtered (("\n\032\032quit\n"));
 273 }
 274
 275 void
 276 annotate_error (void)
 277 {
 278   if (annotation_level > 1)
 279     printf_filtered (("\n\032\032error\n"));
 280 }
 281
 282 void
 283 annotate_error_begin (void)
 284 {
 285   if (annotation_level > 1)
 286     fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
 287 }
 288
 289 void
 290 annotate_value_history_begin (int histindex, struct type *type)
 291 {
 292   if (annotation_level == 2)
 293     {
 294       printf_filtered (("\n\032\032value-history-begin %d "), histindex);
 295       print_value_flags (type);
 296       printf_filtered (("\n"));
 297     }
 298 }
 299
 300 void
 301 annotate_value_begin (struct type *type)
 302 {
 303   if (annotation_level == 2)
 304     {
 305       printf_filtered (("\n\032\032value-begin "));
 306       print_value_flags (type);
 307       printf_filtered (("\n"));
 308     }
 309 }
 310
 311 void
 312 annotate_value_history_value (void)
 313 {
 314   if (annotation_level == 2)
 315     printf_filtered (("\n\032\032value-history-value\n"));
 316 }
 317
 318 void
 319 annotate_value_history_end (void)
 320 {
 321   if (annotation_level == 2)
 322     printf_filtered (("\n\032\032value-history-end\n"));
 323 }
 324
 325 void
 326 annotate_value_end (void)
 327 {
 328   if (annotation_level == 2)
 329     printf_filtered (("\n\032\032value-end\n"));
 330 }
 331
 332 void
 333 annotate_display_begin (void)
 334 {
 335   if (annotation_level == 2)
 336     printf_filtered (("\n\032\032display-begin\n"));
 337 }
 338
 339 void
 340 annotate_display_number_end (void)
 341 {
 342   if (annotation_level == 2)
 343     printf_filtered (("\n\032\032display-number-end\n"));
 344 }
 345
 346 void
 347 annotate_display_format (void)
 348 {
 349   if (annotation_level == 2)
 350     printf_filtered (("\n\032\032display-format\n"));
 351 }
 352
 353 void
 354 annotate_display_expression (void)
 355 {
 356   if (annotation_level == 2)
 357     printf_filtered (("\n\032\032display-expression\n"));
 358 }
 359
 360 void
 361 annotate_display_expression_end (void)
 362 {
 363   if (annotation_level == 2)
 364     printf_filtered (("\n\032\032display-expression-end\n"));
 365 }
 366
 367 void
 368 annotate_display_value (void)
 369 {
 370   if (annotation_level == 2)
 371     printf_filtered (("\n\032\032display-value\n"));
 372 }
 373
 374 void
 375 annotate_display_end (void)
 376 {
 377   if (annotation_level == 2)
 378     printf_filtered (("\n\032\032display-end\n"));
 379 }
 380
 381 void
 382 annotate_arg_begin (void)
 383 {
 384   if (annotation_level == 2)
 385     printf_filtered (("\n\032\032arg-begin\n"));
 386 }
 387
 388 void
 389 annotate_arg_name_end (void)
 390 {
 391   if (annotation_level == 2)
 392     printf_filtered (("\n\032\032arg-name-end\n"));
 393 }
 394
 395 void
 396 annotate_arg_value (struct type *type)
 397 {
 398   if (annotation_level == 2)
 399     {
 400       printf_filtered (("\n\032\032arg-value "));
 401       print_value_flags (type);
 402       printf_filtered (("\n"));
 403     }
 404 }
 405
 406 void
 407 annotate_arg_end (void)
 408 {
 409   if (annotation_level == 2)
 410     printf_filtered (("\n\032\032arg-end\n"));
 411 }
 412
 413 void
 414 annotate_source (char *filename, int line, int character, int mid, 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:0x"), filename,
 422                    line, character,
 423                    mid ? "middle" : "beg");
 424   deprecated_print_address_numeric (pc, 0, gdb_stdout);
 425   printf_filtered (("\n"));
 426 }
 427
 428 void
 429 annotate_frame_begin (int level, CORE_ADDR pc)
 430 {
 431   if (annotation_level > 1)
 432     {
 433       printf_filtered (("\n\032\032frame-begin %d 0x"), level);
 434       deprecated_print_address_numeric (pc, 0, gdb_stdout);
 435       printf_filtered (("\n"));
 436     }
 437 }
 438
 439 void
 440 annotate_function_call (void)
 441 {
 442   if (annotation_level == 2)
 443     printf_filtered (("\n\032\032function-call\n"));
 444 }
 445
 446 void
 447 annotate_signal_handler_caller (void)
 448 {
 449   if (annotation_level == 2)
 450     printf_filtered (("\n\032\032signal-handler-caller\n"));
 451 }
 452
 453 void
 454 annotate_frame_address (void)
 455 {
 456   if (annotation_level == 2)
 457     printf_filtered (("\n\032\032frame-address\n"));
 458 }
 459
 460 void
 461 annotate_frame_address_end (void)
 462 {
 463   if (annotation_level == 2)
 464     printf_filtered (("\n\032\032frame-address-end\n"));
 465 }
 466
 467 void
 468 annotate_frame_function_name (void)
 469 {
 470   if (annotation_level == 2)
 471     printf_filtered (("\n\032\032frame-function-name\n"));
 472 }
 473
 474 void
 475 annotate_frame_args (void)
 476 {
 477   if (annotation_level == 2)
 478     printf_filtered (("\n\032\032frame-args\n"));
 479 }
 480
 481 void
 482 annotate_frame_source_begin (void)
 483 {
 484   if (annotation_level == 2)
 485     printf_filtered (("\n\032\032frame-source-begin\n"));
 486 }
 487
 488 void
 489 annotate_frame_source_file (void)
 490 {
 491   if (annotation_level == 2)
 492     printf_filtered (("\n\032\032frame-source-file\n"));
 493 }
 494
 495 void
 496 annotate_frame_source_file_end (void)
 497 {
 498   if (annotation_level == 2)
 499     printf_filtered (("\n\032\032frame-source-file-end\n"));
 500 }
 501
 502 void
 503 annotate_frame_source_line (void)
 504 {
 505   if (annotation_level == 2)
 506     printf_filtered (("\n\032\032frame-source-line\n"));
 507 }
 508
 509 void
 510 annotate_frame_source_end (void)
 511 {
 512   if (annotation_level == 2)
 513     printf_filtered (("\n\032\032frame-source-end\n"));
 514 }
 515
 516 void
 517 annotate_frame_where (void)
 518 {
 519   if (annotation_level == 2)
 520     printf_filtered (("\n\032\032frame-where\n"));
 521 }
 522
 523 void
 524 annotate_frame_end (void)
 525 {
 526   if (annotation_level == 2)
 527     printf_filtered (("\n\032\032frame-end\n"));
 528 }
 529 \f
 530 void
 531 annotate_array_section_begin (int index, struct type *elttype)
 532 {
 533   if (annotation_level == 2)
 534     {
 535       printf_filtered (("\n\032\032array-section-begin %d "), index);
 536       print_value_flags (elttype);
 537       printf_filtered (("\n"));
 538     }
 539 }
 540
 541 void
 542 annotate_elt_rep (unsigned int repcount)
 543 {
 544   if (annotation_level == 2)
 545     printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
 546 }
 547
 548 void
 549 annotate_elt_rep_end (void)
 550 {
 551   if (annotation_level == 2)
 552     printf_filtered (("\n\032\032elt-rep-end\n"));
 553 }
 554
 555 void
 556 annotate_elt (void)
 557 {
 558   if (annotation_level == 2)
 559     printf_filtered (("\n\032\032elt\n"));
 560 }
 561
 562 void
 563 annotate_array_section_end (void)
 564 {
 565   if (annotation_level == 2)
 566     printf_filtered (("\n\032\032array-section-end\n"));
 567 }
 568
 569 static void
 570 breakpoint_changed (struct breakpoint *b)
 571 {
 572   breakpoints_changed ();
 573 }
 574
 575 void
 576 _initialize_annotate (void)
 577 {
 578   if (annotation_level == 2)
 579     {
 580       deprecated_delete_breakpoint_hook = breakpoint_changed;
 581       deprecated_modify_breakpoint_hook = breakpoint_changed;
 582     }
 583 }