1 /* Annotation routines for GDB. 2 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999, 3 2000, 2007, 2008, 2009, 2010, 2011 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 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 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 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 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 524 void 525 annotate_array_section_begin (int index, struct type *elttype) 526 { 527 if (annotation_level == 2) 528 { 529 printf_filtered (("\n\032\032array-section-begin %d "), index); 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 (int bpno) 565 { 566 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 } 578