GDB (xrefs)

/tmp/gdb-8.1/gdb/observer.inc
Go to the documentation of this file.
1 /* GDB Notifications to Observers.
2
3 Copyright (C) 2004-2018 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 --
21
22 This file was generated using observer.sh and observer.texi. */
23
24
25 /* normal_stop notifications. */
26
27 static struct observer_list *normal_stop_subject = NULL;
28
29 struct normal_stop_args { struct bpstats *bs; int print_frame; };
30
31 static void
32 observer_normal_stop_notification_stub (const void *data, const void *args_data)
33 {
34 observer_normal_stop_ftype *notify = (observer_normal_stop_ftype *) data;
35 const struct normal_stop_args *args = (const struct normal_stop_args *) args_data;
36 notify (args->bs, args->print_frame);
37 }
38
39 struct observer *
40 observer_attach_normal_stop (observer_normal_stop_ftype *f)
41 {
42 return generic_observer_attach (&normal_stop_subject,
43 &observer_normal_stop_notification_stub,
44 (void *) f);
45 }
46
47 void
48 observer_detach_normal_stop (struct observer *observer)
49 {
50 generic_observer_detach (&normal_stop_subject, observer);
51 }
52
53 void
54 observer_notify_normal_stop (struct bpstats *bs, int print_frame)
55 {
56 struct normal_stop_args args;
57 args.bs = bs, args.print_frame = print_frame;
58
59 if (observer_debug)
60 fprintf_unfiltered (gdb_stdlog, "observer_notify_normal_stop() called\n");
61 generic_observer_notify (normal_stop_subject, &args);
62 }
63
64 /* signal_received notifications. */
65
66 static struct observer_list *signal_received_subject = NULL;
67
68 struct signal_received_args { enum gdb_signal siggnal; };
69
70 static void
71 observer_signal_received_notification_stub (const void *data, const void *args_data)
72 {
73 observer_signal_received_ftype *notify = (observer_signal_received_ftype *) data;
74 const struct signal_received_args *args = (const struct signal_received_args *) args_data;
75 notify (args->siggnal);
76 }
77
78 struct observer *
79 observer_attach_signal_received (observer_signal_received_ftype *f)
80 {
81 return generic_observer_attach (&signal_received_subject,
82 &observer_signal_received_notification_stub,
83 (void *) f);
84 }
85
86 void
87 observer_detach_signal_received (struct observer *observer)
88 {
89 generic_observer_detach (&signal_received_subject, observer);
90 }
91
92 void
93 observer_notify_signal_received (enum gdb_signal siggnal)
94 {
95 struct signal_received_args args;
96 args.siggnal = siggnal;
97
98 if (observer_debug)
99 fprintf_unfiltered (gdb_stdlog, "observer_notify_signal_received() called\n");
100 generic_observer_notify (signal_received_subject, &args);
101 }
102
103 /* end_stepping_range notifications. */
104
105 static struct observer_list *end_stepping_range_subject = NULL;
106
107 static void
108 observer_end_stepping_range_notification_stub (const void *data, const void *args_data)
109 {
110 observer_end_stepping_range_ftype *notify = (observer_end_stepping_range_ftype *) data;
111 notify ();
112 }
113
114 struct observer *
115 observer_attach_end_stepping_range (observer_end_stepping_range_ftype *f)
116 {
117 return generic_observer_attach (&end_stepping_range_subject,
118 &observer_end_stepping_range_notification_stub,
119 (void *) f);
120 }
121
122 void
123 observer_detach_end_stepping_range (struct observer *observer)
124 {
125 generic_observer_detach (&end_stepping_range_subject, observer);
126 }
127
128 void
129 observer_notify_end_stepping_range (void)
130 {
131 char *args = NULL;
132 if (observer_debug)
133 fprintf_unfiltered (gdb_stdlog, "observer_notify_end_stepping_range() called\n");
134 generic_observer_notify (end_stepping_range_subject, &args);
135 }
136
137 /* signal_exited notifications. */
138
139 static struct observer_list *signal_exited_subject = NULL;
140
141 struct signal_exited_args { enum gdb_signal siggnal; };
142
143 static void
144 observer_signal_exited_notification_stub (const void *data, const void *args_data)
145 {
146 observer_signal_exited_ftype *notify = (observer_signal_exited_ftype *) data;
147 const struct signal_exited_args *args = (const struct signal_exited_args *) args_data;
148 notify (args->siggnal);
149 }
150
151 struct observer *
152 observer_attach_signal_exited (observer_signal_exited_ftype *f)
153 {
154 return generic_observer_attach (&signal_exited_subject,
155 &observer_signal_exited_notification_stub,
156 (void *) f);
157 }
158
159 void
160 observer_detach_signal_exited (struct observer *observer)
161 {
162 generic_observer_detach (&signal_exited_subject, observer);
163 }
164
165 void
166 observer_notify_signal_exited (enum gdb_signal siggnal)
167 {
168 struct signal_exited_args args;
169 args.siggnal = siggnal;
170
171 if (observer_debug)
172 fprintf_unfiltered (gdb_stdlog, "observer_notify_signal_exited() called\n");
173 generic_observer_notify (signal_exited_subject, &args);
174 }
175
176 /* exited notifications. */
177
178 static struct observer_list *exited_subject = NULL;
179
180 struct exited_args { int exitstatus; };
181
182 static void
183 observer_exited_notification_stub (const void *data, const void *args_data)
184 {
185 observer_exited_ftype *notify = (observer_exited_ftype *) data;
186 const struct exited_args *args = (const struct exited_args *) args_data;
187 notify (args->exitstatus);
188 }
189
190 struct observer *
191 observer_attach_exited (observer_exited_ftype *f)
192 {
193 return generic_observer_attach (&exited_subject,
194 &observer_exited_notification_stub,
195 (void *) f);
196 }
197
198 void
199 observer_detach_exited (struct observer *observer)
200 {
201 generic_observer_detach (&exited_subject, observer);
202 }
203
204 void
205 observer_notify_exited (int exitstatus)
206 {
207 struct exited_args args;
208 args.exitstatus = exitstatus;
209
210 if (observer_debug)
211 fprintf_unfiltered (gdb_stdlog, "observer_notify_exited() called\n");
212 generic_observer_notify (exited_subject, &args);
213 }
214
215 /* no_history notifications. */
216
217 static struct observer_list *no_history_subject = NULL;
218
219 static void
220 observer_no_history_notification_stub (const void *data, const void *args_data)
221 {
222 observer_no_history_ftype *notify = (observer_no_history_ftype *) data;
223 notify ();
224 }
225
226 struct observer *
227 observer_attach_no_history (observer_no_history_ftype *f)
228 {
229 return generic_observer_attach (&no_history_subject,
230 &observer_no_history_notification_stub,
231 (void *) f);
232 }
233
234 void
235 observer_detach_no_history (struct observer *observer)
236 {
237 generic_observer_detach (&no_history_subject, observer);
238 }
239
240 void
241 observer_notify_no_history (void)
242 {
243 char *args = NULL;
244 if (observer_debug)
245 fprintf_unfiltered (gdb_stdlog, "observer_notify_no_history() called\n");
246 generic_observer_notify (no_history_subject, &args);
247 }
248
249 /* sync_execution_done notifications. */
250
251 static struct observer_list *sync_execution_done_subject = NULL;
252
253 static void
254 observer_sync_execution_done_notification_stub (const void *data, const void *args_data)
255 {
256 observer_sync_execution_done_ftype *notify = (observer_sync_execution_done_ftype *) data;
257 notify ();
258 }
259
260 struct observer *
261 observer_attach_sync_execution_done (observer_sync_execution_done_ftype *f)
262 {
263 return generic_observer_attach (&sync_execution_done_subject,
264 &observer_sync_execution_done_notification_stub,
265 (void *) f);
266 }
267
268 void
269 observer_detach_sync_execution_done (struct observer *observer)
270 {
271 generic_observer_detach (&sync_execution_done_subject, observer);
272 }
273
274 void
275 observer_notify_sync_execution_done (void)
276 {
277 char *args = NULL;
278 if (observer_debug)
279 fprintf_unfiltered (gdb_stdlog, "observer_notify_sync_execution_done() called\n");
280 generic_observer_notify (sync_execution_done_subject, &args);
281 }
282
283 /* command_error notifications. */
284
285 static struct observer_list *command_error_subject = NULL;
286
287 static void
288 observer_command_error_notification_stub (const void *data, const void *args_data)
289 {
290 observer_command_error_ftype *notify = (observer_command_error_ftype *) data;
291 notify ();
292 }
293
294 struct observer *
295 observer_attach_command_error (observer_command_error_ftype *f)
296 {
297 return generic_observer_attach (&command_error_subject,
298 &observer_command_error_notification_stub,
299 (void *) f);
300 }
301
302 void
303 observer_detach_command_error (struct observer *observer)
304 {
305 generic_observer_detach (&command_error_subject, observer);
306 }
307
308 void
309 observer_notify_command_error (void)
310 {
311 char *args = NULL;
312 if (observer_debug)
313 fprintf_unfiltered (gdb_stdlog, "observer_notify_command_error() called\n");
314 generic_observer_notify (command_error_subject, &args);
315 }
316
317 /* target_changed notifications. */
318
319 static struct observer_list *target_changed_subject = NULL;
320
321 struct target_changed_args { struct target_ops *target; };
322
323 static void
324 observer_target_changed_notification_stub (const void *data, const void *args_data)
325 {
326 observer_target_changed_ftype *notify = (observer_target_changed_ftype *) data;
327 const struct target_changed_args *args = (const struct target_changed_args *) args_data;
328 notify (args->target);
329 }
330
331 struct observer *
332 observer_attach_target_changed (observer_target_changed_ftype *f)
333 {
334 return generic_observer_attach (&target_changed_subject,
335 &observer_target_changed_notification_stub,
336 (void *) f);
337 }
338
339 void
340 observer_detach_target_changed (struct observer *observer)
341 {
342 generic_observer_detach (&target_changed_subject, observer);
343 }
344
345 void
346 observer_notify_target_changed (struct target_ops *target)
347 {
348 struct target_changed_args args;
349 args.target = target;
350
351 if (observer_debug)
352 fprintf_unfiltered (gdb_stdlog, "observer_notify_target_changed() called\n");
353 generic_observer_notify (target_changed_subject, &args);
354 }
355
356 /* executable_changed notifications. */
357
358 static struct observer_list *executable_changed_subject = NULL;
359
360 static void
361 observer_executable_changed_notification_stub (const void *data, const void *args_data)
362 {
363 observer_executable_changed_ftype *notify = (observer_executable_changed_ftype *) data;
364 notify ();
365 }
366
367 struct observer *
368 observer_attach_executable_changed (observer_executable_changed_ftype *f)
369 {
370 return generic_observer_attach (&executable_changed_subject,
371 &observer_executable_changed_notification_stub,
372 (void *) f);
373 }
374
375 void
376 observer_detach_executable_changed (struct observer *observer)
377 {
378 generic_observer_detach (&executable_changed_subject, observer);
379 }
380
381 void
382 observer_notify_executable_changed (void)
383 {
384 char *args = NULL;
385 if (observer_debug)
386 fprintf_unfiltered (gdb_stdlog, "observer_notify_executable_changed() called\n");
387 generic_observer_notify (executable_changed_subject, &args);
388 }
389
390 /* inferior_created notifications. */
391
392 static struct observer_list *inferior_created_subject = NULL;
393
394 struct inferior_created_args { struct target_ops *objfile; int from_tty; };
395
396 static void
397 observer_inferior_created_notification_stub (const void *data, const void *args_data)
398 {
399 observer_inferior_created_ftype *notify = (observer_inferior_created_ftype *) data;
400 const struct inferior_created_args *args = (const struct inferior_created_args *) args_data;
401 notify (args->objfile, args->from_tty);
402 }
403
404 struct observer *
405 observer_attach_inferior_created (observer_inferior_created_ftype *f)
406 {
407 return generic_observer_attach (&inferior_created_subject,
408 &observer_inferior_created_notification_stub,
409 (void *) f);
410 }
411
412 void
413 observer_detach_inferior_created (struct observer *observer)
414 {
415 generic_observer_detach (&inferior_created_subject, observer);
416 }
417
418 void
419 observer_notify_inferior_created (struct target_ops *objfile, int from_tty)
420 {
421 struct inferior_created_args args;
422 args.objfile = objfile, args.from_tty = from_tty;
423
424 if (observer_debug)
425 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_created() called\n");
426 generic_observer_notify (inferior_created_subject, &args);
427 }
428
429 /* record_changed notifications. */
430
431 static struct observer_list *record_changed_subject = NULL;
432
433 struct record_changed_args { struct inferior *inferior; int started; const char *method; const char *format; };
434
435 static void
436 observer_record_changed_notification_stub (const void *data, const void *args_data)
437 {
438 observer_record_changed_ftype *notify = (observer_record_changed_ftype *) data;
439 const struct record_changed_args *args = (const struct record_changed_args *) args_data;
440 notify (args->inferior, args->started, args->method, args->format);
441 }
442
443 struct observer *
444 observer_attach_record_changed (observer_record_changed_ftype *f)
445 {
446 return generic_observer_attach (&record_changed_subject,
447 &observer_record_changed_notification_stub,
448 (void *) f);
449 }
450
451 void
452 observer_detach_record_changed (struct observer *observer)
453 {
454 generic_observer_detach (&record_changed_subject, observer);
455 }
456
457 void
458 observer_notify_record_changed (struct inferior *inferior, int started, const char *method, const char *format)
459 {
460 struct record_changed_args args;
461 args.inferior = inferior, args.started = started, args.method = method, args.format = format;
462
463 if (observer_debug)
464 fprintf_unfiltered (gdb_stdlog, "observer_notify_record_changed() called\n");
465 generic_observer_notify (record_changed_subject, &args);
466 }
467
468 /* solib_loaded notifications. */
469
470 static struct observer_list *solib_loaded_subject = NULL;
471
472 struct solib_loaded_args { struct so_list *solib; };
473
474 static void
475 observer_solib_loaded_notification_stub (const void *data, const void *args_data)
476 {
477 observer_solib_loaded_ftype *notify = (observer_solib_loaded_ftype *) data;
478 const struct solib_loaded_args *args = (const struct solib_loaded_args *) args_data;
479 notify (args->solib);
480 }
481
482 struct observer *
483 observer_attach_solib_loaded (observer_solib_loaded_ftype *f)
484 {
485 return generic_observer_attach (&solib_loaded_subject,
486 &observer_solib_loaded_notification_stub,
487 (void *) f);
488 }
489
490 void
491 observer_detach_solib_loaded (struct observer *observer)
492 {
493 generic_observer_detach (&solib_loaded_subject, observer);
494 }
495
496 void
497 observer_notify_solib_loaded (struct so_list *solib)
498 {
499 struct solib_loaded_args args;
500 args.solib = solib;
501
502 if (observer_debug)
503 fprintf_unfiltered (gdb_stdlog, "observer_notify_solib_loaded() called\n");
504 generic_observer_notify (solib_loaded_subject, &args);
505 }
506
507 /* solib_unloaded notifications. */
508
509 static struct observer_list *solib_unloaded_subject = NULL;
510
511 struct solib_unloaded_args { struct so_list *solib; };
512
513 static void
514 observer_solib_unloaded_notification_stub (const void *data, const void *args_data)
515 {
516 observer_solib_unloaded_ftype *notify = (observer_solib_unloaded_ftype *) data;
517 const struct solib_unloaded_args *args = (const struct solib_unloaded_args *) args_data;
518 notify (args->solib);
519 }
520
521 struct observer *
522 observer_attach_solib_unloaded (observer_solib_unloaded_ftype *f)
523 {
524 return generic_observer_attach (&solib_unloaded_subject,
525 &observer_solib_unloaded_notification_stub,
526 (void *) f);
527 }
528
529 void
530 observer_detach_solib_unloaded (struct observer *observer)
531 {
532 generic_observer_detach (&solib_unloaded_subject, observer);
533 }
534
535 void
536 observer_notify_solib_unloaded (struct so_list *solib)
537 {
538 struct solib_unloaded_args args;
539 args.solib = solib;
540
541 if (observer_debug)
542 fprintf_unfiltered (gdb_stdlog, "observer_notify_solib_unloaded() called\n");
543 generic_observer_notify (solib_unloaded_subject, &args);
544 }
545
546 /* new_objfile notifications. */
547
548 static struct observer_list *new_objfile_subject = NULL;
549
550 struct new_objfile_args { struct objfile *objfile; };
551
552 static void
553 observer_new_objfile_notification_stub (const void *data, const void *args_data)
554 {
555 observer_new_objfile_ftype *notify = (observer_new_objfile_ftype *) data;
556 const struct new_objfile_args *args = (const struct new_objfile_args *) args_data;
557 notify (args->objfile);
558 }
559
560 struct observer *
561 observer_attach_new_objfile (observer_new_objfile_ftype *f)
562 {
563 return generic_observer_attach (&new_objfile_subject,
564 &observer_new_objfile_notification_stub,
565 (void *) f);
566 }
567
568 void
569 observer_detach_new_objfile (struct observer *observer)
570 {
571 generic_observer_detach (&new_objfile_subject, observer);
572 }
573
574 void
575 observer_notify_new_objfile (struct objfile *objfile)
576 {
577 struct new_objfile_args args;
578 args.objfile = objfile;
579
580 if (observer_debug)
581 fprintf_unfiltered (gdb_stdlog, "observer_notify_new_objfile() called\n");
582 generic_observer_notify (new_objfile_subject, &args);
583 }
584
585 /* free_objfile notifications. */
586
587 static struct observer_list *free_objfile_subject = NULL;
588
589 struct free_objfile_args { struct objfile *objfile; };
590
591 static void
592 observer_free_objfile_notification_stub (const void *data, const void *args_data)
593 {
594 observer_free_objfile_ftype *notify = (observer_free_objfile_ftype *) data;
595 const struct free_objfile_args *args = (const struct free_objfile_args *) args_data;
596 notify (args->objfile);
597 }
598
599 struct observer *
600 observer_attach_free_objfile (observer_free_objfile_ftype *f)
601 {
602 return generic_observer_attach (&free_objfile_subject,
603 &observer_free_objfile_notification_stub,
604 (void *) f);
605 }
606
607 void
608 observer_detach_free_objfile (struct observer *observer)
609 {
610 generic_observer_detach (&free_objfile_subject, observer);
611 }
612
613 void
614 observer_notify_free_objfile (struct objfile *objfile)
615 {
616 struct free_objfile_args args;
617 args.objfile = objfile;
618
619 if (observer_debug)
620 fprintf_unfiltered (gdb_stdlog, "observer_notify_free_objfile() called\n");
621 generic_observer_notify (free_objfile_subject, &args);
622 }
623
624 /* new_thread notifications. */
625
626 static struct observer_list *new_thread_subject = NULL;
627
628 struct new_thread_args { struct thread_info *t; };
629
630 static void
631 observer_new_thread_notification_stub (const void *data, const void *args_data)
632 {
633 observer_new_thread_ftype *notify = (observer_new_thread_ftype *) data;
634 const struct new_thread_args *args = (const struct new_thread_args *) args_data;
635 notify (args->t);
636 }
637
638 struct observer *
639 observer_attach_new_thread (observer_new_thread_ftype *f)
640 {
641 return generic_observer_attach (&new_thread_subject,
642 &observer_new_thread_notification_stub,
643 (void *) f);
644 }
645
646 void
647 observer_detach_new_thread (struct observer *observer)
648 {
649 generic_observer_detach (&new_thread_subject, observer);
650 }
651
652 void
653 observer_notify_new_thread (struct thread_info *t)
654 {
655 struct new_thread_args args;
656 args.t = t;
657
658 if (observer_debug)
659 fprintf_unfiltered (gdb_stdlog, "observer_notify_new_thread() called\n");
660 generic_observer_notify (new_thread_subject, &args);
661 }
662
663 /* thread_exit notifications. */
664
665 static struct observer_list *thread_exit_subject = NULL;
666
667 struct thread_exit_args { struct thread_info *t; int silent; };
668
669 static void
670 observer_thread_exit_notification_stub (const void *data, const void *args_data)
671 {
672 observer_thread_exit_ftype *notify = (observer_thread_exit_ftype *) data;
673 const struct thread_exit_args *args = (const struct thread_exit_args *) args_data;
674 notify (args->t, args->silent);
675 }
676
677 struct observer *
678 observer_attach_thread_exit (observer_thread_exit_ftype *f)
679 {
680 return generic_observer_attach (&thread_exit_subject,
681 &observer_thread_exit_notification_stub,
682 (void *) f);
683 }
684
685 void
686 observer_detach_thread_exit (struct observer *observer)
687 {
688 generic_observer_detach (&thread_exit_subject, observer);
689 }
690
691 void
692 observer_notify_thread_exit (struct thread_info *t, int silent)
693 {
694 struct thread_exit_args args;
695 args.t = t, args.silent = silent;
696
697 if (observer_debug)
698 fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_exit() called\n");
699 generic_observer_notify (thread_exit_subject, &args);
700 }
701
702 /* thread_stop_requested notifications. */
703
704 static struct observer_list *thread_stop_requested_subject = NULL;
705
706 struct thread_stop_requested_args { ptid_t ptid; };
707
708 static void
709 observer_thread_stop_requested_notification_stub (const void *data, const void *args_data)
710 {
711 observer_thread_stop_requested_ftype *notify = (observer_thread_stop_requested_ftype *) data;
712 const struct thread_stop_requested_args *args = (const struct thread_stop_requested_args *) args_data;
713 notify (args->ptid);
714 }
715
716 struct observer *
717 observer_attach_thread_stop_requested (observer_thread_stop_requested_ftype *f)
718 {
719 return generic_observer_attach (&thread_stop_requested_subject,
720 &observer_thread_stop_requested_notification_stub,
721 (void *) f);
722 }
723
724 void
725 observer_detach_thread_stop_requested (struct observer *observer)
726 {
727 generic_observer_detach (&thread_stop_requested_subject, observer);
728 }
729
730 void
731 observer_notify_thread_stop_requested (ptid_t ptid)
732 {
733 struct thread_stop_requested_args args;
734 args.ptid = ptid;
735
736 if (observer_debug)
737 fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_stop_requested() called\n");
738 generic_observer_notify (thread_stop_requested_subject, &args);
739 }
740
741 /* target_resumed notifications. */
742
743 static struct observer_list *target_resumed_subject = NULL;
744
745 struct target_resumed_args { ptid_t ptid; };
746
747 static void
748 observer_target_resumed_notification_stub (const void *data, const void *args_data)
749 {
750 observer_target_resumed_ftype *notify = (observer_target_resumed_ftype *) data;
751 const struct target_resumed_args *args = (const struct target_resumed_args *) args_data;
752 notify (args->ptid);
753 }
754
755 struct observer *
756 observer_attach_target_resumed (observer_target_resumed_ftype *f)
757 {
758 return generic_observer_attach (&target_resumed_subject,
759 &observer_target_resumed_notification_stub,
760 (void *) f);
761 }
762
763 void
764 observer_detach_target_resumed (struct observer *observer)
765 {
766 generic_observer_detach (&target_resumed_subject, observer);
767 }
768
769 void
770 observer_notify_target_resumed (ptid_t ptid)
771 {
772 struct target_resumed_args args;
773 args.ptid = ptid;
774
775 if (observer_debug)
776 fprintf_unfiltered (gdb_stdlog, "observer_notify_target_resumed() called\n");
777 generic_observer_notify (target_resumed_subject, &args);
778 }
779
780 /* about_to_proceed notifications. */
781
782 static struct observer_list *about_to_proceed_subject = NULL;
783
784 static void
785 observer_about_to_proceed_notification_stub (const void *data, const void *args_data)
786 {
787 observer_about_to_proceed_ftype *notify = (observer_about_to_proceed_ftype *) data;
788 notify ();
789 }
790
791 struct observer *
792 observer_attach_about_to_proceed (observer_about_to_proceed_ftype *f)
793 {
794 return generic_observer_attach (&about_to_proceed_subject,
795 &observer_about_to_proceed_notification_stub,
796 (void *) f);
797 }
798
799 void
800 observer_detach_about_to_proceed (struct observer *observer)
801 {
802 generic_observer_detach (&about_to_proceed_subject, observer);
803 }
804
805 void
806 observer_notify_about_to_proceed (void)
807 {
808 char *args = NULL;
809 if (observer_debug)
810 fprintf_unfiltered (gdb_stdlog, "observer_notify_about_to_proceed() called\n");
811 generic_observer_notify (about_to_proceed_subject, &args);
812 }
813
814 /* breakpoint_created notifications. */
815
816 static struct observer_list *breakpoint_created_subject = NULL;
817
818 struct breakpoint_created_args { struct breakpoint *b; };
819
820 static void
821 observer_breakpoint_created_notification_stub (const void *data, const void *args_data)
822 {
823 observer_breakpoint_created_ftype *notify = (observer_breakpoint_created_ftype *) data;
824 const struct breakpoint_created_args *args = (const struct breakpoint_created_args *) args_data;
825 notify (args->b);
826 }
827
828 struct observer *
829 observer_attach_breakpoint_created (observer_breakpoint_created_ftype *f)
830 {
831 return generic_observer_attach (&breakpoint_created_subject,
832 &observer_breakpoint_created_notification_stub,
833 (void *) f);
834 }
835
836 void
837 observer_detach_breakpoint_created (struct observer *observer)
838 {
839 generic_observer_detach (&breakpoint_created_subject, observer);
840 }
841
842 void
843 observer_notify_breakpoint_created (struct breakpoint *b)
844 {
845 struct breakpoint_created_args args;
846 args.b = b;
847
848 if (observer_debug)
849 fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_created() called\n");
850 generic_observer_notify (breakpoint_created_subject, &args);
851 }
852
853 /* breakpoint_deleted notifications. */
854
855 static struct observer_list *breakpoint_deleted_subject = NULL;
856
857 struct breakpoint_deleted_args { struct breakpoint *b; };
858
859 static void
860 observer_breakpoint_deleted_notification_stub (const void *data, const void *args_data)
861 {
862 observer_breakpoint_deleted_ftype *notify = (observer_breakpoint_deleted_ftype *) data;
863 const struct breakpoint_deleted_args *args = (const struct breakpoint_deleted_args *) args_data;
864 notify (args->b);
865 }
866
867 struct observer *
868 observer_attach_breakpoint_deleted (observer_breakpoint_deleted_ftype *f)
869 {
870 return generic_observer_attach (&breakpoint_deleted_subject,
871 &observer_breakpoint_deleted_notification_stub,
872 (void *) f);
873 }
874
875 void
876 observer_detach_breakpoint_deleted (struct observer *observer)
877 {
878 generic_observer_detach (&breakpoint_deleted_subject, observer);
879 }
880
881 void
882 observer_notify_breakpoint_deleted (struct breakpoint *b)
883 {
884 struct breakpoint_deleted_args args;
885 args.b = b;
886
887 if (observer_debug)
888 fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_deleted() called\n");
889 generic_observer_notify (breakpoint_deleted_subject, &args);
890 }
891
892 /* breakpoint_modified notifications. */
893
894 static struct observer_list *breakpoint_modified_subject = NULL;
895
896 struct breakpoint_modified_args { struct breakpoint *b; };
897
898 static void
899 observer_breakpoint_modified_notification_stub (const void *data, const void *args_data)
900 {
901 observer_breakpoint_modified_ftype *notify = (observer_breakpoint_modified_ftype *) data;
902 const struct breakpoint_modified_args *args = (const struct breakpoint_modified_args *) args_data;
903 notify (args->b);
904 }
905
906 struct observer *
907 observer_attach_breakpoint_modified (observer_breakpoint_modified_ftype *f)
908 {
909 return generic_observer_attach (&breakpoint_modified_subject,
910 &observer_breakpoint_modified_notification_stub,
911 (void *) f);
912 }
913
914 void
915 observer_detach_breakpoint_modified (struct observer *observer)
916 {
917 generic_observer_detach (&breakpoint_modified_subject, observer);
918 }
919
920 void
921 observer_notify_breakpoint_modified (struct breakpoint *b)
922 {
923 struct breakpoint_modified_args args;
924 args.b = b;
925
926 if (observer_debug)
927 fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_modified() called\n");
928 generic_observer_notify (breakpoint_modified_subject, &args);
929 }
930
931 /* traceframe_changed notifications. */
932
933 static struct observer_list *traceframe_changed_subject = NULL;
934
935 struct traceframe_changed_args { int tfnum; int tpnum; };
936
937 static void
938 observer_traceframe_changed_notification_stub (const void *data, const void *args_data)
939 {
940 observer_traceframe_changed_ftype *notify = (observer_traceframe_changed_ftype *) data;
941 const struct traceframe_changed_args *args = (const struct traceframe_changed_args *) args_data;
942 notify (args->tfnum, args->tpnum);
943 }
944
945 struct observer *
946 observer_attach_traceframe_changed (observer_traceframe_changed_ftype *f)
947 {
948 return generic_observer_attach (&traceframe_changed_subject,
949 &observer_traceframe_changed_notification_stub,
950 (void *) f);
951 }
952
953 void
954 observer_detach_traceframe_changed (struct observer *observer)
955 {
956 generic_observer_detach (&traceframe_changed_subject, observer);
957 }
958
959 void
960 observer_notify_traceframe_changed (int tfnum, int tpnum)
961 {
962 struct traceframe_changed_args args;
963 args.tfnum = tfnum, args.tpnum = tpnum;
964
965 if (observer_debug)
966 fprintf_unfiltered (gdb_stdlog, "observer_notify_traceframe_changed() called\n");
967 generic_observer_notify (traceframe_changed_subject, &args);
968 }
969
970 /* architecture_changed notifications. */
971
972 static struct observer_list *architecture_changed_subject = NULL;
973
974 struct architecture_changed_args { struct gdbarch *newarch; };
975
976 static void
977 observer_architecture_changed_notification_stub (const void *data, const void *args_data)
978 {
979 observer_architecture_changed_ftype *notify = (observer_architecture_changed_ftype *) data;
980 const struct architecture_changed_args *args = (const struct architecture_changed_args *) args_data;
981 notify (args->newarch);
982 }
983
984 struct observer *
985 observer_attach_architecture_changed (observer_architecture_changed_ftype *f)
986 {
987 return generic_observer_attach (&architecture_changed_subject,
988 &observer_architecture_changed_notification_stub,
989 (void *) f);
990 }
991
992 void
993 observer_detach_architecture_changed (struct observer *observer)
994 {
995 generic_observer_detach (&architecture_changed_subject, observer);
996 }
997
998 void
999 observer_notify_architecture_changed (struct gdbarch *newarch)
1000 {
1001 struct architecture_changed_args args;
1002 args.newarch = newarch;
1003
1004 if (observer_debug)
1005 fprintf_unfiltered (gdb_stdlog, "observer_notify_architecture_changed() called\n");
1006 generic_observer_notify (architecture_changed_subject, &args);
1007 }
1008
1009 /* thread_ptid_changed notifications. */
1010
1011 static struct observer_list *thread_ptid_changed_subject = NULL;
1012
1013 struct thread_ptid_changed_args { ptid_t old_ptid; ptid_t new_ptid; };
1014
1015 static void
1016 observer_thread_ptid_changed_notification_stub (const void *data, const void *args_data)
1017 {
1018 observer_thread_ptid_changed_ftype *notify = (observer_thread_ptid_changed_ftype *) data;
1019 const struct thread_ptid_changed_args *args = (const struct thread_ptid_changed_args *) args_data;
1020 notify (args->old_ptid, args->new_ptid);
1021 }
1022
1023 struct observer *
1024 observer_attach_thread_ptid_changed (observer_thread_ptid_changed_ftype *f)
1025 {
1026 return generic_observer_attach (&thread_ptid_changed_subject,
1027 &observer_thread_ptid_changed_notification_stub,
1028 (void *) f);
1029 }
1030
1031 void
1032 observer_detach_thread_ptid_changed (struct observer *observer)
1033 {
1034 generic_observer_detach (&thread_ptid_changed_subject, observer);
1035 }
1036
1037 void
1038 observer_notify_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
1039 {
1040 struct thread_ptid_changed_args args;
1041 args.old_ptid = old_ptid, args.new_ptid = new_ptid;
1042
1043 if (observer_debug)
1044 fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_ptid_changed() called\n");
1045 generic_observer_notify (thread_ptid_changed_subject, &args);
1046 }
1047
1048 /* inferior_added notifications. */
1049
1050 static struct observer_list *inferior_added_subject = NULL;
1051
1052 struct inferior_added_args { struct inferior *inf; };
1053
1054 static void
1055 observer_inferior_added_notification_stub (const void *data, const void *args_data)
1056 {
1057 observer_inferior_added_ftype *notify = (observer_inferior_added_ftype *) data;
1058 const struct inferior_added_args *args = (const struct inferior_added_args *) args_data;
1059 notify (args->inf);
1060 }
1061
1062 struct observer *
1063 observer_attach_inferior_added (observer_inferior_added_ftype *f)
1064 {
1065 return generic_observer_attach (&inferior_added_subject,
1066 &observer_inferior_added_notification_stub,
1067 (void *) f);
1068 }
1069
1070 void
1071 observer_detach_inferior_added (struct observer *observer)
1072 {
1073 generic_observer_detach (&inferior_added_subject, observer);
1074 }
1075
1076 void
1077 observer_notify_inferior_added (struct inferior *inf)
1078 {
1079 struct inferior_added_args args;
1080 args.inf = inf;
1081
1082 if (observer_debug)
1083 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_added() called\n");
1084 generic_observer_notify (inferior_added_subject, &args);
1085 }
1086
1087 /* inferior_appeared notifications. */
1088
1089 static struct observer_list *inferior_appeared_subject = NULL;
1090
1091 struct inferior_appeared_args { struct inferior *inf; };
1092
1093 static void
1094 observer_inferior_appeared_notification_stub (const void *data, const void *args_data)
1095 {
1096 observer_inferior_appeared_ftype *notify = (observer_inferior_appeared_ftype *) data;
1097 const struct inferior_appeared_args *args = (const struct inferior_appeared_args *) args_data;
1098 notify (args->inf);
1099 }
1100
1101 struct observer *
1102 observer_attach_inferior_appeared (observer_inferior_appeared_ftype *f)
1103 {
1104 return generic_observer_attach (&inferior_appeared_subject,
1105 &observer_inferior_appeared_notification_stub,
1106 (void *) f);
1107 }
1108
1109 void
1110 observer_detach_inferior_appeared (struct observer *observer)
1111 {
1112 generic_observer_detach (&inferior_appeared_subject, observer);
1113 }
1114
1115 void
1116 observer_notify_inferior_appeared (struct inferior *inf)
1117 {
1118 struct inferior_appeared_args args;
1119 args.inf = inf;
1120
1121 if (observer_debug)
1122 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_appeared() called\n");
1123 generic_observer_notify (inferior_appeared_subject, &args);
1124 }
1125
1126 /* inferior_exit notifications. */
1127
1128 static struct observer_list *inferior_exit_subject = NULL;
1129
1130 struct inferior_exit_args { struct inferior *inf; };
1131
1132 static void
1133 observer_inferior_exit_notification_stub (const void *data, const void *args_data)
1134 {
1135 observer_inferior_exit_ftype *notify = (observer_inferior_exit_ftype *) data;
1136 const struct inferior_exit_args *args = (const struct inferior_exit_args *) args_data;
1137 notify (args->inf);
1138 }
1139
1140 struct observer *
1141 observer_attach_inferior_exit (observer_inferior_exit_ftype *f)
1142 {
1143 return generic_observer_attach (&inferior_exit_subject,
1144 &observer_inferior_exit_notification_stub,
1145 (void *) f);
1146 }
1147
1148 void
1149 observer_detach_inferior_exit (struct observer *observer)
1150 {
1151 generic_observer_detach (&inferior_exit_subject, observer);
1152 }
1153
1154 void
1155 observer_notify_inferior_exit (struct inferior *inf)
1156 {
1157 struct inferior_exit_args args;
1158 args.inf = inf;
1159
1160 if (observer_debug)
1161 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_exit() called\n");
1162 generic_observer_notify (inferior_exit_subject, &args);
1163 }
1164
1165 /* inferior_removed notifications. */
1166
1167 static struct observer_list *inferior_removed_subject = NULL;
1168
1169 struct inferior_removed_args { struct inferior *inf; };
1170
1171 static void
1172 observer_inferior_removed_notification_stub (const void *data, const void *args_data)
1173 {
1174 observer_inferior_removed_ftype *notify = (observer_inferior_removed_ftype *) data;
1175 const struct inferior_removed_args *args = (const struct inferior_removed_args *) args_data;
1176 notify (args->inf);
1177 }
1178
1179 struct observer *
1180 observer_attach_inferior_removed (observer_inferior_removed_ftype *f)
1181 {
1182 return generic_observer_attach (&inferior_removed_subject,
1183 &observer_inferior_removed_notification_stub,
1184 (void *) f);
1185 }
1186
1187 void
1188 observer_detach_inferior_removed (struct observer *observer)
1189 {
1190 generic_observer_detach (&inferior_removed_subject, observer);
1191 }
1192
1193 void
1194 observer_notify_inferior_removed (struct inferior *inf)
1195 {
1196 struct inferior_removed_args args;
1197 args.inf = inf;
1198
1199 if (observer_debug)
1200 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_removed() called\n");
1201 generic_observer_notify (inferior_removed_subject, &args);
1202 }
1203
1204 /* memory_changed notifications. */
1205
1206 static struct observer_list *memory_changed_subject = NULL;
1207
1208 struct memory_changed_args { struct inferior *inferior; CORE_ADDR addr; ssize_t len; const bfd_byte *data; };
1209
1210 static void
1211 observer_memory_changed_notification_stub (const void *data, const void *args_data)
1212 {
1213 observer_memory_changed_ftype *notify = (observer_memory_changed_ftype *) data;
1214 const struct memory_changed_args *args = (const struct memory_changed_args *) args_data;
1215 notify (args->inferior, args->addr, args->len, args->data);
1216 }
1217
1218 struct observer *
1219 observer_attach_memory_changed (observer_memory_changed_ftype *f)
1220 {
1221 return generic_observer_attach (&memory_changed_subject,
1222 &observer_memory_changed_notification_stub,
1223 (void *) f);
1224 }
1225
1226 void
1227 observer_detach_memory_changed (struct observer *observer)
1228 {
1229 generic_observer_detach (&memory_changed_subject, observer);
1230 }
1231
1232 void
1233 observer_notify_memory_changed (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
1234 {
1235 struct memory_changed_args args;
1236 args.inferior = inferior, args.addr = addr, args.len = len, args.data = data;
1237
1238 if (observer_debug)
1239 fprintf_unfiltered (gdb_stdlog, "observer_notify_memory_changed() called\n");
1240 generic_observer_notify (memory_changed_subject, &args);
1241 }
1242
1243 /* before_prompt notifications. */
1244
1245 static struct observer_list *before_prompt_subject = NULL;
1246
1247 struct before_prompt_args { const char *current_prompt; };
1248
1249 static void
1250 observer_before_prompt_notification_stub (const void *data, const void *args_data)
1251 {
1252 observer_before_prompt_ftype *notify = (observer_before_prompt_ftype *) data;
1253 const struct before_prompt_args *args = (const struct before_prompt_args *) args_data;
1254 notify (args->current_prompt);
1255 }
1256
1257 struct observer *
1258 observer_attach_before_prompt (observer_before_prompt_ftype *f)
1259 {
1260 return generic_observer_attach (&before_prompt_subject,
1261 &observer_before_prompt_notification_stub,
1262 (void *) f);
1263 }
1264
1265 void
1266 observer_detach_before_prompt (struct observer *observer)
1267 {
1268 generic_observer_detach (&before_prompt_subject, observer);
1269 }
1270
1271 void
1272 observer_notify_before_prompt (const char *current_prompt)
1273 {
1274 struct before_prompt_args args;
1275 args.current_prompt = current_prompt;
1276
1277 if (observer_debug)
1278 fprintf_unfiltered (gdb_stdlog, "observer_notify_before_prompt() called\n");
1279 generic_observer_notify (before_prompt_subject, &args);
1280 }
1281
1282 /* gdb_datadir_changed notifications. */
1283
1284 static struct observer_list *gdb_datadir_changed_subject = NULL;
1285
1286 static void
1287 observer_gdb_datadir_changed_notification_stub (const void *data, const void *args_data)
1288 {
1289 observer_gdb_datadir_changed_ftype *notify = (observer_gdb_datadir_changed_ftype *) data;
1290 notify ();
1291 }
1292
1293 struct observer *
1294 observer_attach_gdb_datadir_changed (observer_gdb_datadir_changed_ftype *f)
1295 {
1296 return generic_observer_attach (&gdb_datadir_changed_subject,
1297 &observer_gdb_datadir_changed_notification_stub,
1298 (void *) f);
1299 }
1300
1301 void
1302 observer_detach_gdb_datadir_changed (struct observer *observer)
1303 {
1304 generic_observer_detach (&gdb_datadir_changed_subject, observer);
1305 }
1306
1307 void
1308 observer_notify_gdb_datadir_changed (void)
1309 {
1310 char *args = NULL;
1311 if (observer_debug)
1312 fprintf_unfiltered (gdb_stdlog, "observer_notify_gdb_datadir_changed() called\n");
1313 generic_observer_notify (gdb_datadir_changed_subject, &args);
1314 }
1315
1316 /* command_param_changed notifications. */
1317
1318 static struct observer_list *command_param_changed_subject = NULL;
1319
1320 struct command_param_changed_args { const char *param; const char *value; };
1321
1322 static void
1323 observer_command_param_changed_notification_stub (const void *data, const void *args_data)
1324 {
1325 observer_command_param_changed_ftype *notify = (observer_command_param_changed_ftype *) data;
1326 const struct command_param_changed_args *args = (const struct command_param_changed_args *) args_data;
1327 notify (args->param, args->value);
1328 }
1329
1330 struct observer *
1331 observer_attach_command_param_changed (observer_command_param_changed_ftype *f)
1332 {
1333 return generic_observer_attach (&command_param_changed_subject,
1334 &observer_command_param_changed_notification_stub,
1335 (void *) f);
1336 }
1337
1338 void
1339 observer_detach_command_param_changed (struct observer *observer)
1340 {
1341 generic_observer_detach (&command_param_changed_subject, observer);
1342 }
1343
1344 void
1345 observer_notify_command_param_changed (const char *param, const char *value)
1346 {
1347 struct command_param_changed_args args;
1348 args.param = param, args.value = value;
1349
1350 if (observer_debug)
1351 fprintf_unfiltered (gdb_stdlog, "observer_notify_command_param_changed() called\n");
1352 generic_observer_notify (command_param_changed_subject, &args);
1353 }
1354
1355 /* tsv_created notifications. */
1356
1357 static struct observer_list *tsv_created_subject = NULL;
1358
1359 struct tsv_created_args { const struct trace_state_variable *tsv; };
1360
1361 static void
1362 observer_tsv_created_notification_stub (const void *data, const void *args_data)
1363 {
1364 observer_tsv_created_ftype *notify = (observer_tsv_created_ftype *) data;
1365 const struct tsv_created_args *args = (const struct tsv_created_args *) args_data;
1366 notify (args->tsv);
1367 }
1368
1369 struct observer *
1370 observer_attach_tsv_created (observer_tsv_created_ftype *f)
1371 {
1372 return generic_observer_attach (&tsv_created_subject,
1373 &observer_tsv_created_notification_stub,
1374 (void *) f);
1375 }
1376
1377 void
1378 observer_detach_tsv_created (struct observer *observer)
1379 {
1380 generic_observer_detach (&tsv_created_subject, observer);
1381 }
1382
1383 void
1384 observer_notify_tsv_created (const struct trace_state_variable *tsv)
1385 {
1386 struct tsv_created_args args;
1387 args.tsv = tsv;
1388
1389 if (observer_debug)
1390 fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_created() called\n");
1391 generic_observer_notify (tsv_created_subject, &args);
1392 }
1393
1394 /* tsv_deleted notifications. */
1395
1396 static struct observer_list *tsv_deleted_subject = NULL;
1397
1398 struct tsv_deleted_args { const struct trace_state_variable *tsv; };
1399
1400 static void
1401 observer_tsv_deleted_notification_stub (const void *data, const void *args_data)
1402 {
1403 observer_tsv_deleted_ftype *notify = (observer_tsv_deleted_ftype *) data;
1404 const struct tsv_deleted_args *args = (const struct tsv_deleted_args *) args_data;
1405 notify (args->tsv);
1406 }
1407
1408 struct observer *
1409 observer_attach_tsv_deleted (observer_tsv_deleted_ftype *f)
1410 {
1411 return generic_observer_attach (&tsv_deleted_subject,
1412 &observer_tsv_deleted_notification_stub,
1413 (void *) f);
1414 }
1415
1416 void
1417 observer_detach_tsv_deleted (struct observer *observer)
1418 {
1419 generic_observer_detach (&tsv_deleted_subject, observer);
1420 }
1421
1422 void
1423 observer_notify_tsv_deleted (const struct trace_state_variable *tsv)
1424 {
1425 struct tsv_deleted_args args;
1426 args.tsv = tsv;
1427
1428 if (observer_debug)
1429 fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_deleted() called\n");
1430 generic_observer_notify (tsv_deleted_subject, &args);
1431 }
1432
1433 /* tsv_modified notifications. */
1434
1435 static struct observer_list *tsv_modified_subject = NULL;
1436
1437 struct tsv_modified_args { const struct trace_state_variable *tsv; };
1438
1439 static void
1440 observer_tsv_modified_notification_stub (const void *data, const void *args_data)
1441 {
1442 observer_tsv_modified_ftype *notify = (observer_tsv_modified_ftype *) data;
1443 const struct tsv_modified_args *args = (const struct tsv_modified_args *) args_data;
1444 notify (args->tsv);
1445 }
1446
1447 struct observer *
1448 observer_attach_tsv_modified (observer_tsv_modified_ftype *f)
1449 {
1450 return generic_observer_attach (&tsv_modified_subject,
1451 &observer_tsv_modified_notification_stub,
1452 (void *) f);
1453 }
1454
1455 void
1456 observer_detach_tsv_modified (struct observer *observer)
1457 {
1458 generic_observer_detach (&tsv_modified_subject, observer);
1459 }
1460
1461 void
1462 observer_notify_tsv_modified (const struct trace_state_variable *tsv)
1463 {
1464 struct tsv_modified_args args;
1465 args.tsv = tsv;
1466
1467 if (observer_debug)
1468 fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_modified() called\n");
1469 generic_observer_notify (tsv_modified_subject, &args);
1470 }
1471
1472 /* inferior_call_pre notifications. */
1473
1474 static struct observer_list *inferior_call_pre_subject = NULL;
1475
1476 struct inferior_call_pre_args { ptid_t thread; CORE_ADDR address; };
1477
1478 static void
1479 observer_inferior_call_pre_notification_stub (const void *data, const void *args_data)
1480 {
1481 observer_inferior_call_pre_ftype *notify = (observer_inferior_call_pre_ftype *) data;
1482 const struct inferior_call_pre_args *args = (const struct inferior_call_pre_args *) args_data;
1483 notify (args->thread, args->address);
1484 }
1485
1486 struct observer *
1487 observer_attach_inferior_call_pre (observer_inferior_call_pre_ftype *f)
1488 {
1489 return generic_observer_attach (&inferior_call_pre_subject,
1490 &observer_inferior_call_pre_notification_stub,
1491 (void *) f);
1492 }
1493
1494 void
1495 observer_detach_inferior_call_pre (struct observer *observer)
1496 {
1497 generic_observer_detach (&inferior_call_pre_subject, observer);
1498 }
1499
1500 void
1501 observer_notify_inferior_call_pre (ptid_t thread, CORE_ADDR address)
1502 {
1503 struct inferior_call_pre_args args;
1504 args.thread = thread, args.address = address;
1505
1506 if (observer_debug)
1507 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_call_pre() called\n");
1508 generic_observer_notify (inferior_call_pre_subject, &args);
1509 }
1510
1511 /* inferior_call_post notifications. */
1512
1513 static struct observer_list *inferior_call_post_subject = NULL;
1514
1515 struct inferior_call_post_args { ptid_t thread; CORE_ADDR address; };
1516
1517 static void
1518 observer_inferior_call_post_notification_stub (const void *data, const void *args_data)
1519 {
1520 observer_inferior_call_post_ftype *notify = (observer_inferior_call_post_ftype *) data;
1521 const struct inferior_call_post_args *args = (const struct inferior_call_post_args *) args_data;
1522 notify (args->thread, args->address);
1523 }
1524
1525 struct observer *
1526 observer_attach_inferior_call_post (observer_inferior_call_post_ftype *f)
1527 {
1528 return generic_observer_attach (&inferior_call_post_subject,
1529 &observer_inferior_call_post_notification_stub,
1530 (void *) f);
1531 }
1532
1533 void
1534 observer_detach_inferior_call_post (struct observer *observer)
1535 {
1536 generic_observer_detach (&inferior_call_post_subject, observer);
1537 }
1538
1539 void
1540 observer_notify_inferior_call_post (ptid_t thread, CORE_ADDR address)
1541 {
1542 struct inferior_call_post_args args;
1543 args.thread = thread, args.address = address;
1544
1545 if (observer_debug)
1546 fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_call_post() called\n");
1547 generic_observer_notify (inferior_call_post_subject, &args);
1548 }
1549
1550 /* register_changed notifications. */
1551
1552 static struct observer_list *register_changed_subject = NULL;
1553
1554 struct register_changed_args { struct frame_info *frame; int regnum; };
1555
1556 static void
1557 observer_register_changed_notification_stub (const void *data, const void *args_data)
1558 {
1559 observer_register_changed_ftype *notify = (observer_register_changed_ftype *) data;
1560 const struct register_changed_args *args = (const struct register_changed_args *) args_data;
1561 notify (args->frame, args->regnum);
1562 }
1563
1564 struct observer *
1565 observer_attach_register_changed (observer_register_changed_ftype *f)
1566 {
1567 return generic_observer_attach (&register_changed_subject,
1568 &observer_register_changed_notification_stub,
1569 (void *) f);
1570 }
1571
1572 void
1573 observer_detach_register_changed (struct observer *observer)
1574 {
1575 generic_observer_detach (&register_changed_subject, observer);
1576 }
1577
1578 void
1579 observer_notify_register_changed (struct frame_info *frame, int regnum)
1580 {
1581 struct register_changed_args args;
1582 args.frame = frame, args.regnum = regnum;
1583
1584 if (observer_debug)
1585 fprintf_unfiltered (gdb_stdlog, "observer_notify_register_changed() called\n");
1586 generic_observer_notify (register_changed_subject, &args);
1587 }
1588
1589 /* test_notification notifications. */
1590
1591 static struct observer_list *test_notification_subject = NULL;
1592
1593 struct test_notification_args { int somearg; };
1594
1595 static void
1596 observer_test_notification_notification_stub (const void *data, const void *args_data)
1597 {
1598 observer_test_notification_ftype *notify = (observer_test_notification_ftype *) data;
1599 const struct test_notification_args *args = (const struct test_notification_args *) args_data;
1600 notify (args->somearg);
1601 }
1602
1603 struct observer *
1604 observer_attach_test_notification (observer_test_notification_ftype *f)
1605 {
1606 return generic_observer_attach (&test_notification_subject,
1607 &observer_test_notification_notification_stub,
1608 (void *) f);
1609 }
1610
1611 void
1612 observer_detach_test_notification (struct observer *observer)
1613 {
1614 generic_observer_detach (&test_notification_subject, observer);
1615 }
1616
1617 void
1618 observer_notify_test_notification (int somearg)
1619 {
1620 struct test_notification_args args;
1621 args.somearg = somearg;
1622
1623 if (observer_debug)
1624 fprintf_unfiltered (gdb_stdlog, "observer_notify_test_notification() called\n");
1625 generic_observer_notify (test_notification_subject, &args);
1626 }
1627
1628 /* user_selected_context_changed notifications. */
1629
1630 static struct observer_list *user_selected_context_changed_subject = NULL;
1631
1632 struct user_selected_context_changed_args { user_selected_what selection; };
1633
1634 static void
1635 observer_user_selected_context_changed_notification_stub (const void *data, const void *args_data)
1636 {
1637 observer_user_selected_context_changed_ftype *notify = (observer_user_selected_context_changed_ftype *) data;
1638 const struct user_selected_context_changed_args *args = (const struct user_selected_context_changed_args *) args_data;
1639 notify (args->selection);
1640 }
1641
1642 struct observer *
1643 observer_attach_user_selected_context_changed (observer_user_selected_context_changed_ftype *f)
1644 {
1645 return generic_observer_attach (&user_selected_context_changed_subject,
1646 &observer_user_selected_context_changed_notification_stub,
1647 (void *) f);
1648 }
1649
1650 void
1651 observer_detach_user_selected_context_changed (struct observer *observer)
1652 {
1653 generic_observer_detach (&user_selected_context_changed_subject, observer);
1654 }
1655
1656 void
1657 observer_notify_user_selected_context_changed (user_selected_what selection)
1658 {
1659 struct user_selected_context_changed_args args;
1660 args.selection = selection;
1661
1662 if (observer_debug)
1663 fprintf_unfiltered (gdb_stdlog, "observer_notify_user_selected_context_changed() called\n");
1664 generic_observer_notify (user_selected_context_changed_subject, &args);
1665 }
gdbarch
Definition: gdbarch.c:127
observer_new_objfile_ftype
void() observer_new_objfile_ftype(struct objfile *objfile)
Definition: observer.h:149
observer_detach_inferior_removed
void observer_detach_inferior_removed(struct observer *observer)
observer_detach_breakpoint_deleted
void observer_detach_breakpoint_deleted(struct observer *observer)
observer_inferior_appeared_ftype
void() observer_inferior_appeared_ftype(struct inferior *inf)
Definition: observer.h:261
observer_attach_record_changed
struct observer * observer_attach_record_changed(observer_record_changed_ftype *f)
observer_detach_thread_ptid_changed
void observer_detach_thread_ptid_changed(struct observer *observer)
observer_attach_breakpoint_deleted
struct observer * observer_attach_breakpoint_deleted(observer_breakpoint_deleted_ftype *f)
observer_notify_breakpoint_created
void observer_notify_breakpoint_created(struct breakpoint *b)
observer_attach_inferior_removed
struct observer * observer_attach_inferior_removed(observer_inferior_removed_ftype *f)
observer_attach_thread_exit
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
observer_detach_solib_loaded
void observer_detach_solib_loaded(struct observer *observer)
observer_attach_free_objfile
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
observer_attach_before_prompt
struct observer * observer_attach_before_prompt(observer_before_prompt_ftype *f)
generic_observer_detach
static void generic_observer_detach(struct observer_list **subject, const struct observer *observer)
Definition: observer.c:131
observer_thread_stop_requested_ftype
void() observer_thread_stop_requested_ftype(ptid_t ptid)
Definition: observer.h:181
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
observer_record_changed_ftype
void() observer_record_changed_ftype(struct inferior *inferior, int started, const char *method, const char *format)
Definition: observer.h:125
observer_thread_ptid_changed_ftype
void() observer_thread_ptid_changed_ftype(ptid_t old_ptid, ptid_t new_ptid)
Definition: observer.h:245
observer_detach_new_objfile
void observer_detach_new_objfile(struct observer *observer)
observer_traceframe_changed_ftype
void() observer_traceframe_changed_ftype(int tfnum, int tpnum)
Definition: observer.h:229
observer_notify_register_changed
void observer_notify_register_changed(struct frame_info *frame, int regnum)
observer_breakpoint_deleted_ftype
void() observer_breakpoint_deleted_ftype(struct breakpoint *b)
Definition: observer.h:213
observer_detach_breakpoint_modified
void observer_detach_breakpoint_modified(struct observer *observer)
observer_memory_changed_ftype
void() observer_memory_changed_ftype(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
Definition: observer.h:285
observer_tsv_created_ftype
void() observer_tsv_created_ftype(const struct trace_state_variable *tsv)
Definition: observer.h:317
observer_attach_executable_changed
struct observer * observer_attach_executable_changed(observer_executable_changed_ftype *f)
observer_notify_normal_stop
void observer_notify_normal_stop(struct bpstats *bs, int print_frame)
observer_detach_tsv_modified
void observer_detach_tsv_modified(struct observer *observer)
observer_attach_signal_exited
struct observer * observer_attach_signal_exited(observer_signal_exited_ftype *f)
inferior
Definition: inferior.h:310
observer_notify_user_selected_context_changed
void observer_notify_user_selected_context_changed(user_selected_what selection)
observer_breakpoint_modified_ftype
void() observer_breakpoint_modified_ftype(struct breakpoint *b)
Definition: observer.h:221
frame_info
Definition: frame.c:85
observer_inferior_exit_ftype
void() observer_inferior_exit_ftype(struct inferior *inf)
Definition: observer.h:269
so_list
Definition: solist.h:38
observer_attach_inferior_exit
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
observer_notify_executable_changed
void observer_notify_executable_changed(void)
observer_detach_inferior_created
void observer_detach_inferior_created(struct observer *observer)
observer_free_objfile_ftype
void() observer_free_objfile_ftype(struct objfile *objfile)
Definition: observer.h:157
observer_about_to_proceed_ftype
void() observer_about_to_proceed_ftype(void)
Definition: observer.h:197
observer_thread_exit_ftype
void() observer_thread_exit_ftype(struct thread_info *t, int silent)
Definition: observer.h:173
observer_notify_sync_execution_done
void observer_notify_sync_execution_done(void)
observer_executable_changed_ftype
void() observer_executable_changed_ftype(void)
Definition: observer.h:109
observer_attach_signal_received
struct observer * observer_attach_signal_received(observer_signal_received_ftype *f)
arm-linux.inf
inf
Definition: arm-linux.py:13
observer_detach_inferior_call_post
void observer_detach_inferior_call_post(struct observer *observer)
observer_detach_thread_stop_requested
void observer_detach_thread_stop_requested(struct observer *observer)
observer_detach_sync_execution_done
void observer_detach_sync_execution_done(struct observer *observer)
observer_notify_inferior_added
void observer_notify_inferior_added(struct inferior *inf)
observer_attach_thread_stop_requested
struct observer * observer_attach_thread_stop_requested(observer_thread_stop_requested_ftype *f)
observer_sync_execution_done_ftype
void() observer_sync_execution_done_ftype(void)
Definition: observer.h:85
observer_notify_traceframe_changed
void observer_notify_traceframe_changed(int tfnum, int tpnum)
observer_detach_traceframe_changed
void observer_detach_traceframe_changed(struct observer *observer)
observer_detach_test_notification
void observer_detach_test_notification(struct observer *observer)
observer_exited_ftype
void() observer_exited_ftype(int exitstatus)
Definition: observer.h:69
observer_notify_free_objfile
void observer_notify_free_objfile(struct objfile *objfile)
observer_attach_inferior_created
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
observer_attach_no_history
struct observer * observer_attach_no_history(observer_no_history_ftype *f)
observer_attach_command_param_changed
struct observer * observer_attach_command_param_changed(observer_command_param_changed_ftype *f)
observer_attach_target_changed
struct observer * observer_attach_target_changed(observer_target_changed_ftype *f)
observer_notify_about_to_proceed
void observer_notify_about_to_proceed(void)
observer_detach_solib_unloaded
void observer_detach_solib_unloaded(struct observer *observer)
observer_detach_architecture_changed
void observer_detach_architecture_changed(struct observer *observer)
observer_detach_memory_changed
void observer_detach_memory_changed(struct observer *observer)
observer_detach_target_resumed
void observer_detach_target_resumed(struct observer *observer)
observer_notify_record_changed
void observer_notify_record_changed(struct inferior *inferior, int started, const char *method, const char *format)
observer_detach_signal_received
void observer_detach_signal_received(struct observer *observer)
observer_detach_tsv_deleted
void observer_detach_tsv_deleted(struct observer *observer)
observer_no_history_ftype
void() observer_no_history_ftype(void)
Definition: observer.h:77
observer_attach_architecture_changed
struct observer * observer_attach_architecture_changed(observer_architecture_changed_ftype *f)
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
target_ops
Definition: target.h:412
observer_notify_solib_unloaded
void observer_notify_solib_unloaded(struct so_list *solib)
observer_solib_loaded_ftype
void() observer_solib_loaded_ftype(struct so_list *solib)
Definition: observer.h:133
observer_attach_tsv_created
struct observer * observer_attach_tsv_created(observer_tsv_created_ftype *f)
ptid_t
Definition: ptid.h:35
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
observer_tsv_deleted_ftype
void() observer_tsv_deleted_ftype(const struct trace_state_variable *tsv)
Definition: observer.h:325
notify
mach_port_t notify
Definition: gnu-nat.c:1811
observer_attach_test_notification
struct observer * observer_attach_test_notification(observer_test_notification_ftype *f)
inferior::inferior
inferior(int pid)
Definition: inferior.c:87
observer_attach_breakpoint_created
struct observer * observer_attach_breakpoint_created(observer_breakpoint_created_ftype *f)
observer_detach_new_thread
void observer_detach_new_thread(struct observer *observer)
observer_attach_solib_unloaded
struct observer * observer_attach_solib_unloaded(observer_solib_unloaded_ftype *f)
observer_notify_target_resumed
void observer_notify_target_resumed(ptid_t ptid)
breakpoint
Definition: breakpoint.h:684
observer_architecture_changed_ftype
void() observer_architecture_changed_ftype(struct gdbarch *newarch)
Definition: observer.h:237
observer_detach_breakpoint_created
void observer_detach_breakpoint_created(struct observer *observer)
observer_detach_command_error
void observer_detach_command_error(struct observer *observer)
observer_attach_command_error
struct observer * observer_attach_command_error(observer_command_error_ftype *f)
inf
Definition: gnu-nat.c:174
observer_detach_register_changed
void observer_detach_register_changed(struct observer *observer)
observer_notify_new_thread
void observer_notify_new_thread(struct thread_info *t)
observer_attach_target_resumed
struct observer * observer_attach_target_resumed(observer_target_resumed_ftype *f)
observer_notify_tsv_modified
void observer_notify_tsv_modified(const struct trace_state_variable *tsv)
observer_attach_exited
struct observer * observer_attach_exited(observer_exited_ftype *f)
observer_debug
static unsigned int observer_debug
Definition: observer.c:57
observer_detach_free_objfile
void observer_detach_free_objfile(struct observer *observer)
observer_inferior_created_ftype
void() observer_inferior_created_ftype(struct target_ops *objfile, int from_tty)
Definition: observer.h:117
regnum
int regnum
Definition: aarch64-tdep.c:77
observer_detach_end_stepping_range
void observer_detach_end_stepping_range(struct observer *observer)
observer_command_error_ftype
void() observer_command_error_ftype(void)
Definition: observer.h:93
observer_tsv_modified_ftype
void() observer_tsv_modified_ftype(const struct trace_state_variable *tsv)
Definition: observer.h:333
observer_attach_inferior_appeared
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
observer_detach_no_history
void observer_detach_no_history(struct observer *observer)
observer_notify_architecture_changed
void observer_notify_architecture_changed(struct gdbarch *newarch)
observer_attach_thread_ptid_changed
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
observer_notify_inferior_removed
void observer_notify_inferior_removed(struct inferior *inf)
observer_new_thread_ftype
void() observer_new_thread_ftype(struct thread_info *t)
Definition: observer.h:165
observer_detach_tsv_created
void observer_detach_tsv_created(struct observer *observer)
observer_notify_breakpoint_deleted
void observer_notify_breakpoint_deleted(struct breakpoint *b)
observer_list
Definition: observer.c:80
observer_detach_command_param_changed
void observer_detach_command_param_changed(struct observer *observer)
observer
Definition: observer.c:70
value
Definition: value.c:169
observer_detach_target_changed
void observer_detach_target_changed(struct observer *observer)
observer_detach_gdb_datadir_changed
void observer_detach_gdb_datadir_changed(struct observer *observer)
observer_detach_normal_stop
void observer_detach_normal_stop(struct observer *observer)
objfile
Definition: objfiles.h:286
observer_breakpoint_created_ftype
void() observer_breakpoint_created_ftype(struct breakpoint *b)
Definition: observer.h:205
observer_attach_tsv_modified
struct observer * observer_attach_tsv_modified(observer_tsv_modified_ftype *f)
observer_notify_tsv_deleted
void observer_notify_tsv_deleted(const struct trace_state_variable *tsv)
observer_notify_inferior_created
void observer_notify_inferior_created(struct target_ops *objfile, int from_tty)
observer_detach_user_selected_context_changed
void observer_detach_user_selected_context_changed(struct observer *observer)
observer_attach_user_selected_context_changed
struct observer * observer_attach_user_selected_context_changed(observer_user_selected_context_changed_ftype *f)
print_frame
static void print_frame(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal)
observer_notify_target_changed
void observer_notify_target_changed(struct target_ops *target)
observer_notify_no_history
void observer_notify_no_history(void)
observer_detach_inferior_appeared
void observer_detach_inferior_appeared(struct observer *observer)
observer_end_stepping_range_ftype
void() observer_end_stepping_range_ftype(void)
Definition: observer.h:53
observer_command_param_changed_ftype
void() observer_command_param_changed_ftype(const char *param, const char *value)
Definition: observer.h:309
observer_detach_signal_exited
void observer_detach_signal_exited(struct observer *observer)
observer_before_prompt_ftype
void() observer_before_prompt_ftype(const char *current_prompt)
Definition: observer.h:293
observer_target_resumed_ftype
void() observer_target_resumed_ftype(ptid_t ptid)
Definition: observer.h:189
observer_attach_register_changed
struct observer * observer_attach_register_changed(observer_register_changed_ftype *f)
observer_attach_breakpoint_modified
struct observer * observer_attach_breakpoint_modified(observer_breakpoint_modified_ftype *f)
trace_state_variable
Definition: tracepoint.h:49
observer_notify_signal_received
void observer_notify_signal_received(enum gdb_signal siggnal)
observer_attach_inferior_call_pre
struct observer * observer_attach_inferior_call_pre(observer_inferior_call_pre_ftype *f)
observer_notify_thread_exit
void observer_notify_thread_exit(struct thread_info *t, int silent)
observer_inferior_added_ftype
void() observer_inferior_added_ftype(struct inferior *inf)
Definition: observer.h:253
observer_notify_test_notification
void observer_notify_test_notification(int somearg)
observer_notify_new_objfile
void observer_notify_new_objfile(struct objfile *objfile)
observer_notify_exited
void observer_notify_exited(int exitstatus)
observer_test_notification_ftype
void() observer_test_notification_ftype(int somearg)
Definition: observer.h:365
observer_detach_executable_changed
void observer_detach_executable_changed(struct observer *observer)
observer_notify_thread_ptid_changed
void observer_notify_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
observer_user_selected_context_changed_ftype
void() observer_user_selected_context_changed_ftype(user_selected_what selection)
Definition: observer.h:373
observer_register_changed_ftype
void() observer_register_changed_ftype(struct frame_info *frame, int regnum)
Definition: observer.h:357
observer_notify_memory_changed
void observer_notify_memory_changed(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
gdbarch::data
void ** data
Definition: gdbarch.c:148
observer_notify_inferior_call_post
void observer_notify_inferior_call_post(ptid_t thread, CORE_ADDR address)
observer::data
void * data
Definition: observer.c:74
observer_notify_command_param_changed
void observer_notify_command_param_changed(const char *param, const char *value)
observer_notify_inferior_call_pre
void observer_notify_inferior_call_pre(ptid_t thread, CORE_ADDR address)
generic_observer_notify
static void generic_observer_notify(struct observer_list *subject, const void *args)
Definition: observer.c:161
observer_attach_inferior_call_post
struct observer * observer_attach_inferior_call_post(observer_inferior_call_post_ftype *f)
observer_notify_thread_stop_requested
void observer_notify_thread_stop_requested(ptid_t ptid)
observer_attach_normal_stop
struct observer * observer_attach_normal_stop(observer_normal_stop_ftype *f)
observer_attach_new_objfile
struct observer * observer_attach_new_objfile(observer_new_objfile_ftype *f)
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
observer_notify_command_error
void observer_notify_command_error(void)
observer_target_changed_ftype
void() observer_target_changed_ftype(struct target_ops *target)
Definition: observer.h:101
observer_attach_new_thread
struct observer * observer_attach_new_thread(observer_new_thread_ftype *f)
observer_detach_before_prompt
void observer_detach_before_prompt(struct observer *observer)
observer_notify_solib_loaded
void observer_notify_solib_loaded(struct so_list *solib)
observer_inferior_call_post_ftype
void() observer_inferior_call_post_ftype(ptid_t thread, CORE_ADDR address)
Definition: observer.h:349
bpstats
Definition: breakpoint.h:1087
observer_detach_thread_exit
void observer_detach_thread_exit(struct observer *observer)
observer_attach_inferior_added
struct observer * observer_attach_inferior_added(observer_inferior_added_ftype *f)
observer_detach_inferior_added
void observer_detach_inferior_added(struct observer *observer)
observer_attach_sync_execution_done
struct observer * observer_attach_sync_execution_done(observer_sync_execution_done_ftype *f)
observer_attach_end_stepping_range
struct observer * observer_attach_end_stepping_range(observer_end_stepping_range_ftype *f)
observer_attach_gdb_datadir_changed
struct observer * observer_attach_gdb_datadir_changed(observer_gdb_datadir_changed_ftype *f)
observer_signal_received_ftype
void() observer_signal_received_ftype(enum gdb_signal siggnal)
Definition: observer.h:45
observer_detach_about_to_proceed
void observer_detach_about_to_proceed(struct observer *observer)
observer_notify_gdb_datadir_changed
void observer_notify_gdb_datadir_changed(void)
observer_inferior_removed_ftype
void() observer_inferior_removed_ftype(struct inferior *inf)
Definition: observer.h:277
observer_inferior_call_pre_ftype
void() observer_inferior_call_pre_ftype(ptid_t thread, CORE_ADDR address)
Definition: observer.h:341
observer_detach_exited
void observer_detach_exited(struct observer *observer)
observer_attach_memory_changed
struct observer * observer_attach_memory_changed(observer_memory_changed_ftype *f)
observer_signal_exited_ftype
void() observer_signal_exited_ftype(enum gdb_signal siggnal)
Definition: observer.h:61
observer_solib_unloaded_ftype
void() observer_solib_unloaded_ftype(struct so_list *solib)
Definition: observer.h:141
observer_normal_stop_ftype
void() observer_normal_stop_ftype(struct bpstats *bs, int print_frame)
Definition: observer.h:37
observer_notify_end_stepping_range
void observer_notify_end_stepping_range(void)
thread_info
Definition: gdbthread.h:205
observer_detach_record_changed
void observer_detach_record_changed(struct observer *observer)
observer_gdb_datadir_changed_ftype
void() observer_gdb_datadir_changed_ftype(void)
Definition: observer.h:301
generic_observer_attach
static struct observer * generic_observer_attach(struct observer_list **subject, generic_observer_notification_ftype *notify, void *data)
Definition: observer.c:113
observer_notify_inferior_appeared
void observer_notify_inferior_appeared(struct inferior *inf)
observer_attach_traceframe_changed
struct observer * observer_attach_traceframe_changed(observer_traceframe_changed_ftype *f)
observer_notify_tsv_created
void observer_notify_tsv_created(const struct trace_state_variable *tsv)
observer_attach_tsv_deleted
struct observer * observer_attach_tsv_deleted(observer_tsv_deleted_ftype *f)
observer_attach_solib_loaded
struct observer * observer_attach_solib_loaded(observer_solib_loaded_ftype *f)
observer_detach_inferior_call_pre
void observer_detach_inferior_call_pre(struct observer *observer)
observer_notify_signal_exited
void observer_notify_signal_exited(enum gdb_signal siggnal)
observer_detach_inferior_exit
void observer_detach_inferior_exit(struct observer *observer)
observer_notify_breakpoint_modified
void observer_notify_breakpoint_modified(struct breakpoint *b)
observer_attach_about_to_proceed
struct observer * observer_attach_about_to_proceed(observer_about_to_proceed_ftype *f)
observer_notify_inferior_exit
void observer_notify_inferior_exit(struct inferior *inf)
observer_notify_before_prompt
void observer_notify_before_prompt(const char *current_prompt)