GDB (xrefs)
/tmp/gdb-7.10/gdb/observer.inc
Go to the documentation of this file.
1 /* GDB Notifications to Observers.
2 
3  Copyright (C) 2004-2015 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 {
35  const struct normal_stop_args *args = args_data;
36  notify (args->bs, args->print_frame);
37 }
38 
39 struct observer *
41 {
42  return generic_observer_attach (&normal_stop_subject,
43  &observer_normal_stop_notification_stub,
44  (void *) f);
45 }
46 
47 void
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 {
74  const struct signal_received_args *args = args_data;
75  notify (args->siggnal);
76 }
77 
78 struct observer *
80 {
81  return generic_observer_attach (&signal_received_subject,
82  &observer_signal_received_notification_stub,
83  (void *) f);
84 }
85 
86 void
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 {
111  notify ();
112 }
113 
114 struct observer *
116 {
117  return generic_observer_attach (&end_stepping_range_subject,
118  &observer_end_stepping_range_notification_stub,
119  (void *) f);
120 }
121 
122 void
124 {
125  generic_observer_detach (&end_stepping_range_subject, observer);
126 }
127 
128 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 {
147  const struct signal_exited_args *args = args_data;
148  notify (args->siggnal);
149 }
150 
151 struct observer *
153 {
154  return generic_observer_attach (&signal_exited_subject,
155  &observer_signal_exited_notification_stub,
156  (void *) f);
157 }
158 
159 void
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 {
186  const struct exited_args *args = args_data;
187  notify (args->exitstatus);
188 }
189 
190 struct observer *
192 {
193  return generic_observer_attach (&exited_subject,
194  &observer_exited_notification_stub,
195  (void *) f);
196 }
197 
198 void
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 {
223  notify ();
224 }
225 
226 struct observer *
228 {
229  return generic_observer_attach (&no_history_subject,
230  &observer_no_history_notification_stub,
231  (void *) f);
232 }
233 
234 void
236 {
237  generic_observer_detach (&no_history_subject, observer);
238 }
239 
240 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 {
257  notify ();
258 }
259 
260 struct observer *
262 {
263  return generic_observer_attach (&sync_execution_done_subject,
264  &observer_sync_execution_done_notification_stub,
265  (void *) f);
266 }
267 
268 void
270 {
271  generic_observer_detach (&sync_execution_done_subject, observer);
272 }
273 
274 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 {
291  notify ();
292 }
293 
294 struct observer *
296 {
297  return generic_observer_attach (&command_error_subject,
298  &observer_command_error_notification_stub,
299  (void *) f);
300 }
301 
302 void
304 {
305  generic_observer_detach (&command_error_subject, observer);
306 }
307 
308 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 {
327  const struct target_changed_args *args = args_data;
328  notify (args->target);
329 }
330 
331 struct observer *
333 {
334  return generic_observer_attach (&target_changed_subject,
335  &observer_target_changed_notification_stub,
336  (void *) f);
337 }
338 
339 void
341 {
342  generic_observer_detach (&target_changed_subject, observer);
343 }
344 
345 void
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 {
364  notify ();
365 }
366 
367 struct observer *
369 {
370  return generic_observer_attach (&executable_changed_subject,
371  &observer_executable_changed_notification_stub,
372  (void *) f);
373 }
374 
375 void
377 {
378  generic_observer_detach (&executable_changed_subject, observer);
379 }
380 
381 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 {
400  const struct inferior_created_args *args = args_data;
401  notify (args->objfile, args->from_tty);
402 }
403 
404 struct observer *
406 {
407  return generic_observer_attach (&inferior_created_subject,
408  &observer_inferior_created_notification_stub,
409  (void *) f);
410 }
411 
412 void
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; };
434 
435 static void
436 observer_record_changed_notification_stub (const void *data, const void *args_data)
437 {
439  const struct record_changed_args *args = args_data;
440  notify (args->inferior, args->started);
441 }
442 
443 struct observer *
445 {
446  return generic_observer_attach (&record_changed_subject,
447  &observer_record_changed_notification_stub,
448  (void *) f);
449 }
450 
451 void
453 {
454  generic_observer_detach (&record_changed_subject, observer);
455 }
456 
457 void
458 observer_notify_record_changed (struct inferior *inferior, int started)
459 {
460  struct record_changed_args args;
461  args.inferior = inferior, args.started = started;
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 {
478  const struct solib_loaded_args *args = args_data;
479  notify (args->solib);
480 }
481 
482 struct observer *
484 {
485  return generic_observer_attach (&solib_loaded_subject,
486  &observer_solib_loaded_notification_stub,
487  (void *) f);
488 }
489 
490 void
492 {
493  generic_observer_detach (&solib_loaded_subject, observer);
494 }
495 
496 void
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 {
517  const struct solib_unloaded_args *args = args_data;
518  notify (args->solib);
519 }
520 
521 struct observer *
523 {
524  return generic_observer_attach (&solib_unloaded_subject,
525  &observer_solib_unloaded_notification_stub,
526  (void *) f);
527 }
528 
529 void
531 {
532  generic_observer_detach (&solib_unloaded_subject, observer);
533 }
534 
535 void
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 {
556  const struct new_objfile_args *args = args_data;
557  notify (args->objfile);
558 }
559 
560 struct observer *
562 {
563  return generic_observer_attach (&new_objfile_subject,
564  &observer_new_objfile_notification_stub,
565  (void *) f);
566 }
567 
568 void
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 {
595  const struct free_objfile_args *args = args_data;
596  notify (args->objfile);
597 }
598 
599 struct observer *
601 {
602  return generic_observer_attach (&free_objfile_subject,
603  &observer_free_objfile_notification_stub,
604  (void *) f);
605 }
606 
607 void
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 {
634  const struct new_thread_args *args = args_data;
635  notify (args->t);
636 }
637 
638 struct observer *
640 {
641  return generic_observer_attach (&new_thread_subject,
642  &observer_new_thread_notification_stub,
643  (void *) f);
644 }
645 
646 void
648 {
649  generic_observer_detach (&new_thread_subject, observer);
650 }
651 
652 void
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 {
673  const struct thread_exit_args *args = args_data;
674  notify (args->t, args->silent);
675 }
676 
677 struct observer *
679 {
680  return generic_observer_attach (&thread_exit_subject,
681  &observer_thread_exit_notification_stub,
682  (void *) f);
683 }
684 
685 void
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 {
712  const struct thread_stop_requested_args *args = args_data;
713  notify (args->ptid);
714 }
715 
716 struct observer *
718 {
719  return generic_observer_attach (&thread_stop_requested_subject,
720  &observer_thread_stop_requested_notification_stub,
721  (void *) f);
722 }
723 
724 void
726 {
727  generic_observer_detach (&thread_stop_requested_subject, observer);
728 }
729 
730 void
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 {
751  const struct target_resumed_args *args = args_data;
752  notify (args->ptid);
753 }
754 
755 struct observer *
757 {
758  return generic_observer_attach (&target_resumed_subject,
759  &observer_target_resumed_notification_stub,
760  (void *) f);
761 }
762 
763 void
765 {
766  generic_observer_detach (&target_resumed_subject, observer);
767 }
768 
769 void
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 {
788  notify ();
789 }
790 
791 struct observer *
793 {
794  return generic_observer_attach (&about_to_proceed_subject,
795  &observer_about_to_proceed_notification_stub,
796  (void *) f);
797 }
798 
799 void
801 {
802  generic_observer_detach (&about_to_proceed_subject, observer);
803 }
804 
805 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 {
824  const struct breakpoint_created_args *args = args_data;
825  notify (args->b);
826 }
827 
828 struct observer *
830 {
831  return generic_observer_attach (&breakpoint_created_subject,
832  &observer_breakpoint_created_notification_stub,
833  (void *) f);
834 }
835 
836 void
838 {
839  generic_observer_detach (&breakpoint_created_subject, observer);
840 }
841 
842 void
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 {
863  const struct breakpoint_deleted_args *args = args_data;
864  notify (args->b);
865 }
866 
867 struct observer *
869 {
870  return generic_observer_attach (&breakpoint_deleted_subject,
871  &observer_breakpoint_deleted_notification_stub,
872  (void *) f);
873 }
874 
875 void
877 {
878  generic_observer_detach (&breakpoint_deleted_subject, observer);
879 }
880 
881 void
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 {
902  const struct breakpoint_modified_args *args = args_data;
903  notify (args->b);
904 }
905 
906 struct observer *
908 {
909  return generic_observer_attach (&breakpoint_modified_subject,
910  &observer_breakpoint_modified_notification_stub,
911  (void *) f);
912 }
913 
914 void
916 {
917  generic_observer_detach (&breakpoint_modified_subject, observer);
918 }
919 
920 void
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 {
941  const struct traceframe_changed_args *args = args_data;
942  notify (args->tfnum, args->tpnum);
943 }
944 
945 struct observer *
947 {
948  return generic_observer_attach (&traceframe_changed_subject,
949  &observer_traceframe_changed_notification_stub,
950  (void *) f);
951 }
952 
953 void
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 {
980  const struct architecture_changed_args *args = args_data;
981  notify (args->newarch);
982 }
983 
984 struct observer *
986 {
987  return generic_observer_attach (&architecture_changed_subject,
988  &observer_architecture_changed_notification_stub,
989  (void *) f);
990 }
991 
992 void
994 {
995  generic_observer_detach (&architecture_changed_subject, observer);
996 }
997 
998 void
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 {
1019  const struct thread_ptid_changed_args *args = args_data;
1020  notify (args->old_ptid, args->new_ptid);
1021 }
1022 
1023 struct observer *
1025 {
1026  return generic_observer_attach (&thread_ptid_changed_subject,
1027  &observer_thread_ptid_changed_notification_stub,
1028  (void *) f);
1029 }
1030 
1031 void
1033 {
1034  generic_observer_detach (&thread_ptid_changed_subject, observer);
1035 }
1036 
1037 void
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 {
1058  const struct inferior_added_args *args = args_data;
1059  notify (args->inf);
1060 }
1061 
1062 struct observer *
1064 {
1065  return generic_observer_attach (&inferior_added_subject,
1066  &observer_inferior_added_notification_stub,
1067  (void *) f);
1068 }
1069 
1070 void
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 {
1097  const struct inferior_appeared_args *args = args_data;
1098  notify (args->inf);
1099 }
1100 
1101 struct observer *
1103 {
1104  return generic_observer_attach (&inferior_appeared_subject,
1105  &observer_inferior_appeared_notification_stub,
1106  (void *) f);
1107 }
1108 
1109 void
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 {
1136  const struct inferior_exit_args *args = args_data;
1137  notify (args->inf);
1138 }
1139 
1140 struct observer *
1142 {
1143  return generic_observer_attach (&inferior_exit_subject,
1144  &observer_inferior_exit_notification_stub,
1145  (void *) f);
1146 }
1147 
1148 void
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 {
1175  const struct inferior_removed_args *args = args_data;
1176  notify (args->inf);
1177 }
1178 
1179 struct observer *
1181 {
1182  return generic_observer_attach (&inferior_removed_subject,
1183  &observer_inferior_removed_notification_stub,
1184  (void *) f);
1185 }
1186 
1187 void
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 {
1214  const struct memory_changed_args *args = args_data;
1215  notify (args->inferior, args->addr, args->len, args->data);
1216 }
1217 
1218 struct observer *
1220 {
1221  return generic_observer_attach (&memory_changed_subject,
1222  &observer_memory_changed_notification_stub,
1223  (void *) f);
1224 }
1225 
1226 void
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 {
1253  const struct before_prompt_args *args = args_data;
1254  notify (args->current_prompt);
1255 }
1256 
1257 struct observer *
1259 {
1260  return generic_observer_attach (&before_prompt_subject,
1261  &observer_before_prompt_notification_stub,
1262  (void *) f);
1263 }
1264 
1265 void
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 {
1290  notify ();
1291 }
1292 
1293 struct observer *
1295 {
1296  return generic_observer_attach (&gdb_datadir_changed_subject,
1297  &observer_gdb_datadir_changed_notification_stub,
1298  (void *) f);
1299 }
1300 
1301 void
1303 {
1304  generic_observer_detach (&gdb_datadir_changed_subject, observer);
1305 }
1306 
1307 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 {
1326  const struct command_param_changed_args *args = args_data;
1327  notify (args->param, args->value);
1328 }
1329 
1330 struct observer *
1332 {
1333  return generic_observer_attach (&command_param_changed_subject,
1334  &observer_command_param_changed_notification_stub,
1335  (void *) f);
1336 }
1337 
1338 void
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 {
1365  const struct tsv_created_args *args = args_data;
1366  notify (args->tsv);
1367 }
1368 
1369 struct observer *
1371 {
1372  return generic_observer_attach (&tsv_created_subject,
1373  &observer_tsv_created_notification_stub,
1374  (void *) f);
1375 }
1376 
1377 void
1379 {
1380  generic_observer_detach (&tsv_created_subject, observer);
1381 }
1382 
1383 void
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 {
1404  const struct tsv_deleted_args *args = args_data;
1405  notify (args->tsv);
1406 }
1407 
1408 struct observer *
1410 {
1411  return generic_observer_attach (&tsv_deleted_subject,
1412  &observer_tsv_deleted_notification_stub,
1413  (void *) f);
1414 }
1415 
1416 void
1418 {
1419  generic_observer_detach (&tsv_deleted_subject, observer);
1420 }
1421 
1422 void
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 {
1443  const struct tsv_modified_args *args = args_data;
1444  notify (args->tsv);
1445 }
1446 
1447 struct observer *
1449 {
1450  return generic_observer_attach (&tsv_modified_subject,
1451  &observer_tsv_modified_notification_stub,
1452  (void *) f);
1453 }
1454 
1455 void
1457 {
1458  generic_observer_detach (&tsv_modified_subject, observer);
1459 }
1460 
1461 void
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 {
1482  const struct inferior_call_pre_args *args = args_data;
1483  notify (args->thread, args->address);
1484 }
1485 
1486 struct observer *
1488 {
1489  return generic_observer_attach (&inferior_call_pre_subject,
1490  &observer_inferior_call_pre_notification_stub,
1491  (void *) f);
1492 }
1493 
1494 void
1496 {
1497  generic_observer_detach (&inferior_call_pre_subject, observer);
1498 }
1499 
1500 void
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 {
1521  const struct inferior_call_post_args *args = args_data;
1522  notify (args->thread, args->address);
1523 }
1524 
1525 struct observer *
1527 {
1528  return generic_observer_attach (&inferior_call_post_subject,
1529  &observer_inferior_call_post_notification_stub,
1530  (void *) f);
1531 }
1532 
1533 void
1535 {
1536  generic_observer_detach (&inferior_call_post_subject, observer);
1537 }
1538 
1539 void
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 {
1560  const struct register_changed_args *args = args_data;
1561  notify (args->frame, args->regnum);
1562 }
1563 
1564 struct observer *
1566 {
1567  return generic_observer_attach (&register_changed_subject,
1568  &observer_register_changed_notification_stub,
1569  (void *) f);
1570 }
1571 
1572 void
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 {
1599  const struct test_notification_args *args = args_data;
1600  notify (args->somearg);
1601 }
1602 
1603 struct observer *
1605 {
1606  return generic_observer_attach (&test_notification_subject,
1607  &observer_test_notification_notification_stub,
1608  (void *) f);
1609 }
1610 
1611 void
1613 {
1614  generic_observer_detach (&test_notification_subject, observer);
1615 }
1616 
1617 void
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 }
void( observer_normal_stop_ftype)(struct bpstats *bs, int print_frame)
Definition: observer.h:37
void( observer_thread_ptid_changed_ftype)(ptid_t old_ptid, ptid_t new_ptid)
Definition: observer.h:245
void observer_detach_inferior_removed(struct observer *observer)
void observer_detach_breakpoint_deleted(struct observer *observer)
void( observer_breakpoint_created_ftype)(struct breakpoint *b)
Definition: observer.h:205
struct observer * observer_attach_record_changed(observer_record_changed_ftype *f)
void observer_detach_thread_ptid_changed(struct observer *observer)
struct observer * observer_attach_breakpoint_deleted(observer_breakpoint_deleted_ftype *f)
void observer_notify_breakpoint_created(struct breakpoint *b)
void( observer_sync_execution_done_ftype)(void)
Definition: observer.h:85
struct observer * observer_attach_inferior_removed(observer_inferior_removed_ftype *f)
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
void( observer_command_param_changed_ftype)(const char *param, const char *value)
Definition: observer.h:309
void observer_detach_solib_loaded(struct observer *observer)
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
struct observer * observer_attach_before_prompt(observer_before_prompt_ftype *f)
static void generic_observer_detach(struct observer_list **subject, const struct observer *observer)
Definition: observer.c:131
void( observer_inferior_removed_ftype)(struct inferior *inf)
Definition: observer.h:277
bfd_vma CORE_ADDR
Definition: common-types.h:41
void observer_detach_new_objfile(struct observer *observer)
void observer_notify_register_changed(struct frame_info *frame, int regnum)
tuple inf
Definition: arm-linux.py:13
void observer_detach_breakpoint_modified(struct observer *observer)
void( observer_executable_changed_ftype)(void)
Definition: observer.h:109
void( observer_thread_exit_ftype)(struct thread_info *t, int silent)
Definition: observer.h:173
void( observer_inferior_created_ftype)(struct target_ops *objfile, int from_tty)
Definition: observer.h:117
struct observer * observer_attach_executable_changed(observer_executable_changed_ftype *f)
void observer_notify_normal_stop(struct bpstats *bs, int print_frame)
void observer_detach_tsv_modified(struct observer *observer)
struct observer * observer_attach_signal_exited(observer_signal_exited_ftype *f)
void( observer_tsv_deleted_ftype)(const struct trace_state_variable *tsv)
Definition: observer.h:325
void( observer_inferior_call_post_ftype)(ptid_t thread, CORE_ADDR address)
Definition: observer.h:349
Definition: solist.h:30
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
void observer_notify_executable_changed(void)
void observer_detach_inferior_created(struct observer *observer)
void( observer_solib_loaded_ftype)(struct so_list *solib)
Definition: observer.h:133
void observer_notify_sync_execution_done(void)
void( observer_traceframe_changed_ftype)(int tfnum, int tpnum)
Definition: observer.h:229
struct observer * observer_attach_signal_received(observer_signal_received_ftype *f)
void( observer_breakpoint_modified_ftype)(struct breakpoint *b)
Definition: observer.h:221
void( observer_target_changed_ftype)(struct target_ops *target)
Definition: observer.h:101
void( observer_tsv_modified_ftype)(const struct trace_state_variable *tsv)
Definition: observer.h:333
void observer_detach_inferior_call_post(struct observer *observer)
void observer_detach_thread_stop_requested(struct observer *observer)
void observer_detach_sync_execution_done(struct observer *observer)
void observer_notify_inferior_added(struct inferior *inf)
struct observer * observer_attach_thread_stop_requested(observer_thread_stop_requested_ftype *f)
Definition: ptid.h:35
void observer_notify_traceframe_changed(int tfnum, int tpnum)
void observer_detach_traceframe_changed(struct observer *observer)
void observer_detach_test_notification(struct observer *observer)
void( observer_thread_stop_requested_ftype)(ptid_t ptid)
Definition: observer.h:181
void observer_notify_free_objfile(struct objfile *objfile)
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
struct observer * observer_attach_no_history(observer_no_history_ftype *f)
struct observer * observer_attach_command_param_changed(observer_command_param_changed_ftype *f)
struct observer * observer_attach_target_changed(observer_target_changed_ftype *f)
void observer_notify_about_to_proceed(void)
void observer_detach_solib_unloaded(struct observer *observer)
void observer_detach_architecture_changed(struct observer *observer)
void observer_detach_memory_changed(struct observer *observer)
void observer_detach_target_resumed(struct observer *observer)
void( observer_free_objfile_ftype)(struct objfile *objfile)
Definition: observer.h:157
void( observer_about_to_proceed_ftype)(void)
Definition: observer.h:197
void observer_detach_signal_received(struct observer *observer)
void observer_detach_tsv_deleted(struct observer *observer)
struct observer * observer_attach_architecture_changed(observer_architecture_changed_ftype *f)
void( observer_register_changed_ftype)(struct frame_info *frame, int regnum)
Definition: observer.h:357
void observer_notify_solib_unloaded(struct so_list *solib)
void( observer_inferior_call_pre_ftype)(ptid_t thread, CORE_ADDR address)
Definition: observer.h:341
struct observer * observer_attach_tsv_created(observer_tsv_created_ftype *f)
void( observer_record_changed_ftype)(struct inferior *inferior, int started)
Definition: observer.h:125
void( observer_tsv_created_ftype)(const struct trace_state_variable *tsv)
Definition: observer.h:317
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t notify
Definition: gnu-nat.c:1805
struct observer * observer_attach_test_notification(observer_test_notification_ftype *f)
struct observer * observer_attach_breakpoint_created(observer_breakpoint_created_ftype *f)
void observer_detach_new_thread(struct observer *observer)
struct observer * observer_attach_solib_unloaded(observer_solib_unloaded_ftype *f)
void observer_notify_target_resumed(ptid_t ptid)
void( observer_gdb_datadir_changed_ftype)(void)
Definition: observer.h:301
void( observer_signal_exited_ftype)(enum gdb_signal siggnal)
Definition: observer.h:61
void observer_detach_breakpoint_created(struct observer *observer)
void observer_detach_command_error(struct observer *observer)
struct observer * observer_attach_command_error(observer_command_error_ftype *f)
void( observer_end_stepping_range_ftype)(void)
Definition: observer.h:53
void observer_notify_record_changed(struct inferior *inferior, int started)
void observer_detach_register_changed(struct observer *observer)
void observer_notify_new_thread(struct thread_info *t)
struct observer * observer_attach_target_resumed(observer_target_resumed_ftype *f)
void observer_notify_tsv_modified(const struct trace_state_variable *tsv)
struct observer * observer_attach_exited(observer_exited_ftype *f)
void( observer_test_notification_ftype)(int somearg)
Definition: observer.h:365
static unsigned int observer_debug
Definition: observer.c:57
void observer_detach_free_objfile(struct observer *observer)
void( observer_before_prompt_ftype)(const char *current_prompt)
Definition: observer.h:293
int regnum
Definition: aarch64-tdep.c:69
void observer_detach_end_stepping_range(struct observer *observer)
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
void observer_detach_no_history(struct observer *observer)
struct ui_file * gdb_stdlog
Definition: main.c:73
void observer_notify_architecture_changed(struct gdbarch *newarch)
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
void observer_notify_inferior_removed(struct inferior *inf)
void observer_detach_tsv_created(struct observer *observer)
void observer_notify_breakpoint_deleted(struct breakpoint *b)
void( observer_inferior_appeared_ftype)(struct inferior *inf)
Definition: observer.h:261
void observer_detach_command_param_changed(struct observer *observer)
void( observer_command_error_ftype)(void)
Definition: observer.h:93
void observer_detach_target_changed(struct observer *observer)
void observer_detach_gdb_datadir_changed(struct observer *observer)
void observer_detach_normal_stop(struct observer *observer)
struct observer * observer_attach_tsv_modified(observer_tsv_modified_ftype *f)
void observer_notify_tsv_deleted(const struct trace_state_variable *tsv)
void observer_notify_inferior_created(struct target_ops *objfile, int from_tty)
static void print_frame(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal)
void observer_notify_target_changed(struct target_ops *target)
void observer_notify_no_history(void)
void observer_detach_inferior_appeared(struct observer *observer)
void( observer_target_resumed_ftype)(ptid_t ptid)
Definition: observer.h:189
void observer_detach_signal_exited(struct observer *observer)
struct observer * observer_attach_register_changed(observer_register_changed_ftype *f)
struct observer * observer_attach_breakpoint_modified(observer_breakpoint_modified_ftype *f)
void observer_notify_signal_received(enum gdb_signal siggnal)
struct observer * observer_attach_inferior_call_pre(observer_inferior_call_pre_ftype *f)
void observer_notify_thread_exit(struct thread_info *t, int silent)
void observer_notify_test_notification(int somearg)
void( observer_new_objfile_ftype)(struct objfile *objfile)
Definition: observer.h:149
void observer_notify_new_objfile(struct objfile *objfile)
void observer_notify_exited(int exitstatus)
void( observer_memory_changed_ftype)(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
Definition: observer.h:285
void observer_detach_executable_changed(struct observer *observer)
void observer_notify_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
void observer_notify_memory_changed(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
void observer_notify_inferior_call_post(ptid_t thread, CORE_ADDR address)
void( observer_exited_ftype)(int exitstatus)
Definition: observer.h:69
void observer_notify_command_param_changed(const char *param, const char *value)
void observer_notify_inferior_call_pre(ptid_t thread, CORE_ADDR address)
static void generic_observer_notify(struct observer_list *subject, const void *args)
Definition: observer.c:161
struct observer * observer_attach_inferior_call_post(observer_inferior_call_post_ftype *f)
void observer_notify_thread_stop_requested(ptid_t ptid)
void( observer_inferior_added_ftype)(struct inferior *inf)
Definition: observer.h:253
void( observer_no_history_ftype)(void)
Definition: observer.h:77
void( observer_new_thread_ftype)(struct thread_info *t)
Definition: observer.h:165
struct observer * observer_attach_normal_stop(observer_normal_stop_ftype *f)
struct observer * observer_attach_new_objfile(observer_new_objfile_ftype *f)
void observer_notify_command_error(void)
struct observer * observer_attach_new_thread(observer_new_thread_ftype *f)
void observer_detach_before_prompt(struct observer *observer)
void observer_notify_solib_loaded(struct so_list *solib)
void observer_detach_thread_exit(struct observer *observer)
struct observer * observer_attach_inferior_added(observer_inferior_added_ftype *f)
void( observer_breakpoint_deleted_ftype)(struct breakpoint *b)
Definition: observer.h:213
void observer_detach_inferior_added(struct observer *observer)
void( observer_solib_unloaded_ftype)(struct so_list *solib)
Definition: observer.h:141
struct observer * observer_attach_sync_execution_done(observer_sync_execution_done_ftype *f)
struct observer * observer_attach_end_stepping_range(observer_end_stepping_range_ftype *f)
struct observer * observer_attach_gdb_datadir_changed(observer_gdb_datadir_changed_ftype *f)
void observer_detach_about_to_proceed(struct observer *observer)
void observer_notify_gdb_datadir_changed(void)
void observer_detach_exited(struct observer *observer)
struct observer * observer_attach_memory_changed(observer_memory_changed_ftype *f)
void observer_notify_end_stepping_range(void)
void observer_detach_record_changed(struct observer *observer)
static struct observer * generic_observer_attach(struct observer_list **subject, generic_observer_notification_ftype *notify, void *data)
Definition: observer.c:113
void( observer_signal_received_ftype)(enum gdb_signal siggnal)
Definition: observer.h:45
void observer_notify_inferior_appeared(struct inferior *inf)
struct observer * observer_attach_traceframe_changed(observer_traceframe_changed_ftype *f)
void observer_notify_tsv_created(const struct trace_state_variable *tsv)
struct observer * observer_attach_tsv_deleted(observer_tsv_deleted_ftype *f)
struct observer * observer_attach_solib_loaded(observer_solib_loaded_ftype *f)
void observer_detach_inferior_call_pre(struct observer *observer)
void observer_notify_signal_exited(enum gdb_signal siggnal)
void observer_detach_inferior_exit(struct observer *observer)
void( observer_inferior_exit_ftype)(struct inferior *inf)
Definition: observer.h:269
void( observer_architecture_changed_ftype)(struct gdbarch *newarch)
Definition: observer.h:237
void observer_notify_breakpoint_modified(struct breakpoint *b)
struct observer * observer_attach_about_to_proceed(observer_about_to_proceed_ftype *f)
void observer_notify_inferior_exit(struct inferior *inf)
const ULONGEST const LONGEST len
Definition: target.h:309
void observer_notify_before_prompt(const char *current_prompt)