]>
Commit | Line | Data |
---|---|---|
1 | /* Annotation routines for GDB. | |
2 | Copyright (C) 1986-2024 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 3 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
18 | ||
19 | #include "annotate.h" | |
20 | #include "value.h" | |
21 | #include "target.h" | |
22 | #include "gdbtypes.h" | |
23 | #include "breakpoint.h" | |
24 | #include "observable.h" | |
25 | #include "inferior.h" | |
26 | #include "infrun.h" | |
27 | #include "source.h" | |
28 | #include "objfiles.h" | |
29 | #include "source-cache.h" | |
30 | #include "ui.h" | |
31 | ||
32 | /* See annotate.h. */ | |
33 | ||
34 | int annotation_level = 0; | |
35 | ||
36 | /* Prototypes for local functions. */ | |
37 | ||
38 | static void print_value_flags (struct type *); | |
39 | ||
40 | static void breakpoint_changed (struct breakpoint *b); | |
41 | ||
42 | ||
43 | void (*deprecated_annotate_signalled_hook) (void); | |
44 | void (*deprecated_annotate_signal_hook) (void); | |
45 | ||
46 | /* Booleans indicating whether we've emitted certain notifications. | |
47 | Used to suppress useless repeated notifications until the next time | |
48 | we're ready to accept more commands. Reset whenever a prompt is | |
49 | displayed. */ | |
50 | static int frames_invalid_emitted; | |
51 | static int breakpoints_invalid_emitted; | |
52 | ||
53 | static void | |
54 | print_value_flags (struct type *t) | |
55 | { | |
56 | if (can_dereference (t)) | |
57 | printf_unfiltered (("*")); | |
58 | else | |
59 | printf_unfiltered (("-")); | |
60 | } | |
61 | ||
62 | static void | |
63 | annotate_breakpoints_invalid (void) | |
64 | { | |
65 | if (annotation_level == 2 | |
66 | && (!breakpoints_invalid_emitted | |
67 | || current_ui->prompt_state != PROMPT_BLOCKED)) | |
68 | { | |
69 | target_terminal::scoped_restore_terminal_state term_state; | |
70 | target_terminal::ours_for_output (); | |
71 | ||
72 | printf_unfiltered (("\n\032\032breakpoints-invalid\n")); | |
73 | breakpoints_invalid_emitted = 1; | |
74 | } | |
75 | } | |
76 | ||
77 | void | |
78 | annotate_breakpoint (int num) | |
79 | { | |
80 | if (annotation_level > 1) | |
81 | printf_unfiltered (("\n\032\032breakpoint %d\n"), num); | |
82 | } | |
83 | ||
84 | void | |
85 | annotate_catchpoint (int num) | |
86 | { | |
87 | if (annotation_level > 1) | |
88 | printf_unfiltered (("\n\032\032catchpoint %d\n"), num); | |
89 | } | |
90 | ||
91 | void | |
92 | annotate_watchpoint (int num) | |
93 | { | |
94 | if (annotation_level > 1) | |
95 | printf_unfiltered (("\n\032\032watchpoint %d\n"), num); | |
96 | } | |
97 | ||
98 | void | |
99 | annotate_starting (void) | |
100 | { | |
101 | if (annotation_level > 1) | |
102 | printf_unfiltered (("\n\032\032starting\n")); | |
103 | } | |
104 | ||
105 | void | |
106 | annotate_stopped (void) | |
107 | { | |
108 | if (annotation_level > 1) | |
109 | printf_unfiltered (("\n\032\032stopped\n")); | |
110 | } | |
111 | ||
112 | void | |
113 | annotate_exited (int exitstatus) | |
114 | { | |
115 | if (annotation_level > 1) | |
116 | printf_unfiltered (("\n\032\032exited %d\n"), exitstatus); | |
117 | } | |
118 | ||
119 | void | |
120 | annotate_signalled (void) | |
121 | { | |
122 | if (deprecated_annotate_signalled_hook) | |
123 | deprecated_annotate_signalled_hook (); | |
124 | ||
125 | if (annotation_level > 1) | |
126 | printf_unfiltered (("\n\032\032signalled\n")); | |
127 | } | |
128 | ||
129 | void | |
130 | annotate_signal_name (void) | |
131 | { | |
132 | if (annotation_level == 2) | |
133 | printf_unfiltered (("\n\032\032signal-name\n")); | |
134 | } | |
135 | ||
136 | void | |
137 | annotate_signal_name_end (void) | |
138 | { | |
139 | if (annotation_level == 2) | |
140 | printf_unfiltered (("\n\032\032signal-name-end\n")); | |
141 | } | |
142 | ||
143 | void | |
144 | annotate_signal_string (void) | |
145 | { | |
146 | if (annotation_level == 2) | |
147 | printf_unfiltered (("\n\032\032signal-string\n")); | |
148 | } | |
149 | ||
150 | void | |
151 | annotate_signal_string_end (void) | |
152 | { | |
153 | if (annotation_level == 2) | |
154 | printf_unfiltered (("\n\032\032signal-string-end\n")); | |
155 | } | |
156 | ||
157 | void | |
158 | annotate_signal (void) | |
159 | { | |
160 | if (deprecated_annotate_signal_hook) | |
161 | deprecated_annotate_signal_hook (); | |
162 | ||
163 | if (annotation_level > 1) | |
164 | printf_unfiltered (("\n\032\032signal\n")); | |
165 | } | |
166 | \f | |
167 | void | |
168 | annotate_breakpoints_headers (void) | |
169 | { | |
170 | if (annotation_level == 2) | |
171 | printf_unfiltered (("\n\032\032breakpoints-headers\n")); | |
172 | } | |
173 | ||
174 | void | |
175 | annotate_field (int num) | |
176 | { | |
177 | if (annotation_level == 2) | |
178 | printf_unfiltered (("\n\032\032field %d\n"), num); | |
179 | } | |
180 | ||
181 | void | |
182 | annotate_breakpoints_table (void) | |
183 | { | |
184 | if (annotation_level == 2) | |
185 | printf_unfiltered (("\n\032\032breakpoints-table\n")); | |
186 | } | |
187 | ||
188 | void | |
189 | annotate_record (void) | |
190 | { | |
191 | if (annotation_level == 2) | |
192 | printf_unfiltered (("\n\032\032record\n")); | |
193 | } | |
194 | ||
195 | void | |
196 | annotate_breakpoints_table_end (void) | |
197 | { | |
198 | if (annotation_level == 2) | |
199 | printf_unfiltered (("\n\032\032breakpoints-table-end\n")); | |
200 | } | |
201 | ||
202 | void | |
203 | annotate_frames_invalid (void) | |
204 | { | |
205 | if (annotation_level == 2 | |
206 | && (!frames_invalid_emitted | |
207 | || current_ui->prompt_state != PROMPT_BLOCKED)) | |
208 | { | |
209 | target_terminal::scoped_restore_terminal_state term_state; | |
210 | target_terminal::ours_for_output (); | |
211 | ||
212 | printf_unfiltered (("\n\032\032frames-invalid\n")); | |
213 | frames_invalid_emitted = 1; | |
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 | /* Emit notification on thread exit. */ | |
236 | ||
237 | static void | |
238 | annotate_thread_exited (thread_info *t, | |
239 | std::optional<ULONGEST> exit_code, | |
240 | bool /* silent */) | |
241 | { | |
242 | if (annotation_level > 1) | |
243 | { | |
244 | printf_unfiltered (("\n\032\032thread-exited," | |
245 | "id=\"%d\",group-id=\"i%d\"\n"), | |
246 | t->global_num, t->inf->num); | |
247 | } | |
248 | } | |
249 | ||
250 | void | |
251 | annotate_field_begin (struct type *type) | |
252 | { | |
253 | if (annotation_level == 2) | |
254 | { | |
255 | printf_unfiltered (("\n\032\032field-begin ")); | |
256 | print_value_flags (type); | |
257 | printf_unfiltered (("\n")); | |
258 | } | |
259 | } | |
260 | ||
261 | void | |
262 | annotate_field_name_end (void) | |
263 | { | |
264 | if (annotation_level == 2) | |
265 | printf_unfiltered (("\n\032\032field-name-end\n")); | |
266 | } | |
267 | ||
268 | void | |
269 | annotate_field_value (void) | |
270 | { | |
271 | if (annotation_level == 2) | |
272 | printf_unfiltered (("\n\032\032field-value\n")); | |
273 | } | |
274 | ||
275 | void | |
276 | annotate_field_end (void) | |
277 | { | |
278 | if (annotation_level == 2) | |
279 | printf_unfiltered (("\n\032\032field-end\n")); | |
280 | } | |
281 | \f | |
282 | void | |
283 | annotate_quit (void) | |
284 | { | |
285 | if (annotation_level > 1) | |
286 | printf_unfiltered (("\n\032\032quit\n")); | |
287 | } | |
288 | ||
289 | void | |
290 | annotate_error (void) | |
291 | { | |
292 | if (annotation_level > 1) | |
293 | printf_unfiltered (("\n\032\032error\n")); | |
294 | } | |
295 | ||
296 | void | |
297 | annotate_error_begin (void) | |
298 | { | |
299 | if (annotation_level > 1) | |
300 | gdb_printf (gdb_stderr, "\n\032\032error-begin\n"); | |
301 | } | |
302 | ||
303 | void | |
304 | annotate_value_history_begin (int histindex, struct type *type) | |
305 | { | |
306 | if (annotation_level == 2) | |
307 | { | |
308 | printf_unfiltered (("\n\032\032value-history-begin %d "), histindex); | |
309 | print_value_flags (type); | |
310 | printf_unfiltered (("\n")); | |
311 | } | |
312 | } | |
313 | ||
314 | void | |
315 | annotate_value_begin (struct type *type) | |
316 | { | |
317 | if (annotation_level == 2) | |
318 | { | |
319 | printf_unfiltered (("\n\032\032value-begin ")); | |
320 | print_value_flags (type); | |
321 | printf_unfiltered (("\n")); | |
322 | } | |
323 | } | |
324 | ||
325 | void | |
326 | annotate_value_history_value (void) | |
327 | { | |
328 | if (annotation_level == 2) | |
329 | printf_unfiltered (("\n\032\032value-history-value\n")); | |
330 | } | |
331 | ||
332 | void | |
333 | annotate_value_history_end (void) | |
334 | { | |
335 | if (annotation_level == 2) | |
336 | printf_unfiltered (("\n\032\032value-history-end\n")); | |
337 | } | |
338 | ||
339 | void | |
340 | annotate_value_end (void) | |
341 | { | |
342 | if (annotation_level == 2) | |
343 | printf_unfiltered (("\n\032\032value-end\n")); | |
344 | } | |
345 | ||
346 | void | |
347 | annotate_display_begin (void) | |
348 | { | |
349 | if (annotation_level == 2) | |
350 | printf_unfiltered (("\n\032\032display-begin\n")); | |
351 | } | |
352 | ||
353 | void | |
354 | annotate_display_number_end (void) | |
355 | { | |
356 | if (annotation_level == 2) | |
357 | printf_unfiltered (("\n\032\032display-number-end\n")); | |
358 | } | |
359 | ||
360 | void | |
361 | annotate_display_format (void) | |
362 | { | |
363 | if (annotation_level == 2) | |
364 | printf_unfiltered (("\n\032\032display-format\n")); | |
365 | } | |
366 | ||
367 | void | |
368 | annotate_display_expression (void) | |
369 | { | |
370 | if (annotation_level == 2) | |
371 | printf_unfiltered (("\n\032\032display-expression\n")); | |
372 | } | |
373 | ||
374 | void | |
375 | annotate_display_expression_end (void) | |
376 | { | |
377 | if (annotation_level == 2) | |
378 | printf_unfiltered (("\n\032\032display-expression-end\n")); | |
379 | } | |
380 | ||
381 | void | |
382 | annotate_display_value (void) | |
383 | { | |
384 | if (annotation_level == 2) | |
385 | printf_unfiltered (("\n\032\032display-value\n")); | |
386 | } | |
387 | ||
388 | void | |
389 | annotate_display_end (void) | |
390 | { | |
391 | if (annotation_level == 2) | |
392 | printf_unfiltered (("\n\032\032display-end\n")); | |
393 | } | |
394 | ||
395 | void | |
396 | annotate_arg_begin (void) | |
397 | { | |
398 | if (annotation_level == 2) | |
399 | printf_unfiltered (("\n\032\032arg-begin\n")); | |
400 | } | |
401 | ||
402 | void | |
403 | annotate_arg_name_end (void) | |
404 | { | |
405 | if (annotation_level == 2) | |
406 | printf_unfiltered (("\n\032\032arg-name-end\n")); | |
407 | } | |
408 | ||
409 | void | |
410 | annotate_arg_value (struct type *type) | |
411 | { | |
412 | if (annotation_level == 2) | |
413 | { | |
414 | printf_unfiltered (("\n\032\032arg-value ")); | |
415 | print_value_flags (type); | |
416 | printf_unfiltered (("\n")); | |
417 | } | |
418 | } | |
419 | ||
420 | void | |
421 | annotate_arg_end (void) | |
422 | { | |
423 | if (annotation_level == 2) | |
424 | printf_unfiltered (("\n\032\032arg-end\n")); | |
425 | } | |
426 | ||
427 | static void | |
428 | annotate_source (const char *filename, int line, int character, int mid, | |
429 | struct gdbarch *gdbarch, CORE_ADDR pc) | |
430 | { | |
431 | if (annotation_level > 1) | |
432 | printf_unfiltered (("\n\032\032source ")); | |
433 | else | |
434 | printf_unfiltered (("\032\032")); | |
435 | ||
436 | printf_unfiltered (("%s:%d:%d:%s:%s\n"), filename, line, character, | |
437 | mid ? "middle" : "beg", paddress (gdbarch, pc)); | |
438 | } | |
439 | ||
440 | /* See annotate.h. */ | |
441 | ||
442 | bool | |
443 | annotate_source_line (struct symtab *s, int line, int mid_statement, | |
444 | CORE_ADDR pc) | |
445 | { | |
446 | if (annotation_level > 0) | |
447 | { | |
448 | const std::vector<off_t> *offsets; | |
449 | if (!g_source_cache.get_line_charpos (s, &offsets)) | |
450 | return false; | |
451 | if (line > offsets->size ()) | |
452 | return false; | |
453 | ||
454 | annotate_source (s->fullname (), line, (int) (*offsets)[line - 1], | |
455 | mid_statement, s->compunit ()->objfile ()->arch (), | |
456 | pc); | |
457 | ||
458 | /* Update the current symtab and line. */ | |
459 | symtab_and_line sal; | |
460 | sal.pspace = s->compunit ()->objfile ()->pspace (); | |
461 | sal.symtab = s; | |
462 | sal.line = line; | |
463 | set_current_source_symtab_and_line (sal); | |
464 | ||
465 | return true; | |
466 | } | |
467 | ||
468 | return false; | |
469 | } | |
470 | ||
471 | ||
472 | void | |
473 | annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc) | |
474 | { | |
475 | if (annotation_level > 1) | |
476 | printf_unfiltered (("\n\032\032frame-begin %d %s\n"), | |
477 | level, paddress (gdbarch, pc)); | |
478 | } | |
479 | ||
480 | void | |
481 | annotate_function_call (void) | |
482 | { | |
483 | if (annotation_level == 2) | |
484 | printf_unfiltered (("\n\032\032function-call\n")); | |
485 | } | |
486 | ||
487 | void | |
488 | annotate_signal_handler_caller (void) | |
489 | { | |
490 | if (annotation_level == 2) | |
491 | printf_unfiltered (("\n\032\032signal-handler-caller\n")); | |
492 | } | |
493 | ||
494 | void | |
495 | annotate_frame_address (void) | |
496 | { | |
497 | if (annotation_level == 2) | |
498 | printf_unfiltered (("\n\032\032frame-address\n")); | |
499 | } | |
500 | ||
501 | void | |
502 | annotate_frame_address_end (void) | |
503 | { | |
504 | if (annotation_level == 2) | |
505 | printf_unfiltered (("\n\032\032frame-address-end\n")); | |
506 | } | |
507 | ||
508 | void | |
509 | annotate_frame_function_name (void) | |
510 | { | |
511 | if (annotation_level == 2) | |
512 | printf_unfiltered (("\n\032\032frame-function-name\n")); | |
513 | } | |
514 | ||
515 | void | |
516 | annotate_frame_args (void) | |
517 | { | |
518 | if (annotation_level == 2) | |
519 | printf_unfiltered (("\n\032\032frame-args\n")); | |
520 | } | |
521 | ||
522 | void | |
523 | annotate_frame_source_begin (void) | |
524 | { | |
525 | if (annotation_level == 2) | |
526 | printf_unfiltered (("\n\032\032frame-source-begin\n")); | |
527 | } | |
528 | ||
529 | void | |
530 | annotate_frame_source_file (void) | |
531 | { | |
532 | if (annotation_level == 2) | |
533 | printf_unfiltered (("\n\032\032frame-source-file\n")); | |
534 | } | |
535 | ||
536 | void | |
537 | annotate_frame_source_file_end (void) | |
538 | { | |
539 | if (annotation_level == 2) | |
540 | printf_unfiltered (("\n\032\032frame-source-file-end\n")); | |
541 | } | |
542 | ||
543 | void | |
544 | annotate_frame_source_line (void) | |
545 | { | |
546 | if (annotation_level == 2) | |
547 | printf_unfiltered (("\n\032\032frame-source-line\n")); | |
548 | } | |
549 | ||
550 | void | |
551 | annotate_frame_source_end (void) | |
552 | { | |
553 | if (annotation_level == 2) | |
554 | printf_unfiltered (("\n\032\032frame-source-end\n")); | |
555 | } | |
556 | ||
557 | void | |
558 | annotate_frame_where (void) | |
559 | { | |
560 | if (annotation_level == 2) | |
561 | printf_unfiltered (("\n\032\032frame-where\n")); | |
562 | } | |
563 | ||
564 | void | |
565 | annotate_frame_end (void) | |
566 | { | |
567 | if (annotation_level == 2) | |
568 | printf_unfiltered (("\n\032\032frame-end\n")); | |
569 | } | |
570 | \f | |
571 | void | |
572 | annotate_array_section_begin (int idx, struct type *elttype) | |
573 | { | |
574 | if (annotation_level == 2) | |
575 | { | |
576 | printf_unfiltered (("\n\032\032array-section-begin %d "), idx); | |
577 | print_value_flags (elttype); | |
578 | printf_unfiltered (("\n")); | |
579 | } | |
580 | } | |
581 | ||
582 | void | |
583 | annotate_elt_rep (unsigned int repcount) | |
584 | { | |
585 | if (annotation_level == 2) | |
586 | printf_unfiltered (("\n\032\032elt-rep %u\n"), repcount); | |
587 | } | |
588 | ||
589 | void | |
590 | annotate_elt_rep_end (void) | |
591 | { | |
592 | if (annotation_level == 2) | |
593 | printf_unfiltered (("\n\032\032elt-rep-end\n")); | |
594 | } | |
595 | ||
596 | void | |
597 | annotate_elt (void) | |
598 | { | |
599 | if (annotation_level == 2) | |
600 | printf_unfiltered (("\n\032\032elt\n")); | |
601 | } | |
602 | ||
603 | void | |
604 | annotate_array_section_end (void) | |
605 | { | |
606 | if (annotation_level == 2) | |
607 | printf_unfiltered (("\n\032\032array-section-end\n")); | |
608 | } | |
609 | ||
610 | /* Called when GDB is about to display the prompt. Used to reset | |
611 | annotation suppression whenever we're ready to accept new | |
612 | frontend/user commands. */ | |
613 | ||
614 | void | |
615 | annotate_display_prompt (void) | |
616 | { | |
617 | frames_invalid_emitted = 0; | |
618 | breakpoints_invalid_emitted = 0; | |
619 | } | |
620 | ||
621 | static void | |
622 | breakpoint_changed (struct breakpoint *b) | |
623 | { | |
624 | if (b->number <= 0) | |
625 | return; | |
626 | ||
627 | annotate_breakpoints_invalid (); | |
628 | } | |
629 | ||
630 | void _initialize_annotate (); | |
631 | void | |
632 | _initialize_annotate () | |
633 | { | |
634 | gdb::observers::breakpoint_created.attach (breakpoint_changed, "annotate"); | |
635 | gdb::observers::breakpoint_deleted.attach (breakpoint_changed, "annotate"); | |
636 | gdb::observers::breakpoint_modified.attach (breakpoint_changed, "annotate"); | |
637 | gdb::observers::thread_exit.attach (annotate_thread_exited, "annotate"); | |
638 | } |