xref: /netbsd-current/external/gpl3/gdb.old/lib/libgdb/arch/mipsn64el/observer.inc

/* This file is automatically generated.  DO NOT EDIT! */
/* Generated from: NetBSD: mknative-gdb,v 1.7 2016/10/16 04:37:42 mrg Exp  */
/* Generated from: NetBSD: mknative.common,v 1.15 2017/11/29 03:32:28 christos Exp  */

/* GDB Notifications to Observers.

   Copyright (C) 2004-2017 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.

   --

   This file was generated using observer.sh and observer.texi.  */


/* normal_stop notifications.  */

static struct observer_list *normal_stop_subject = NULL;

struct normal_stop_args { struct bpstats *bs; int print_frame; };

static void
observer_normal_stop_notification_stub (const void *data, const void *args_data)
{
  observer_normal_stop_ftype *notify = (observer_normal_stop_ftype *) data;
  const struct normal_stop_args *args = (const struct normal_stop_args *) args_data;
  notify (args->bs, args->print_frame);
}

struct observer *
observer_attach_normal_stop (observer_normal_stop_ftype *f)
{
  return generic_observer_attach (&normal_stop_subject,
				  &observer_normal_stop_notification_stub,
				  (void *) f);
}

void
observer_detach_normal_stop (struct observer *observer)
{
  generic_observer_detach (&normal_stop_subject, observer);
}

void
observer_notify_normal_stop (struct bpstats *bs, int print_frame)
{
  struct normal_stop_args args;
  args.bs = bs, args.print_frame = print_frame;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_normal_stop() called\n");
  generic_observer_notify (normal_stop_subject, &args);
}

/* signal_received notifications.  */

static struct observer_list *signal_received_subject = NULL;

struct signal_received_args { enum gdb_signal siggnal; };

static void
observer_signal_received_notification_stub (const void *data, const void *args_data)
{
  observer_signal_received_ftype *notify = (observer_signal_received_ftype *) data;
  const struct signal_received_args *args = (const struct signal_received_args *) args_data;
  notify (args->siggnal);
}

struct observer *
observer_attach_signal_received (observer_signal_received_ftype *f)
{
  return generic_observer_attach (&signal_received_subject,
				  &observer_signal_received_notification_stub,
				  (void *) f);
}

void
observer_detach_signal_received (struct observer *observer)
{
  generic_observer_detach (&signal_received_subject, observer);
}

void
observer_notify_signal_received (enum gdb_signal siggnal)
{
  struct signal_received_args args;
  args.siggnal = siggnal;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_signal_received() called\n");
  generic_observer_notify (signal_received_subject, &args);
}

/* end_stepping_range notifications.  */

static struct observer_list *end_stepping_range_subject = NULL;

static void
observer_end_stepping_range_notification_stub (const void *data, const void *args_data)
{
  observer_end_stepping_range_ftype *notify = (observer_end_stepping_range_ftype *) data;
  notify ();
}

struct observer *
observer_attach_end_stepping_range (observer_end_stepping_range_ftype *f)
{
  return generic_observer_attach (&end_stepping_range_subject,
				  &observer_end_stepping_range_notification_stub,
				  (void *) f);
}

void
observer_detach_end_stepping_range (struct observer *observer)
{
  generic_observer_detach (&end_stepping_range_subject, observer);
}

void
observer_notify_end_stepping_range (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_end_stepping_range() called\n");
  generic_observer_notify (end_stepping_range_subject, &args);
}

/* signal_exited notifications.  */

static struct observer_list *signal_exited_subject = NULL;

struct signal_exited_args { enum gdb_signal siggnal; };

static void
observer_signal_exited_notification_stub (const void *data, const void *args_data)
{
  observer_signal_exited_ftype *notify = (observer_signal_exited_ftype *) data;
  const struct signal_exited_args *args = (const struct signal_exited_args *) args_data;
  notify (args->siggnal);
}

struct observer *
observer_attach_signal_exited (observer_signal_exited_ftype *f)
{
  return generic_observer_attach (&signal_exited_subject,
				  &observer_signal_exited_notification_stub,
				  (void *) f);
}

void
observer_detach_signal_exited (struct observer *observer)
{
  generic_observer_detach (&signal_exited_subject, observer);
}

void
observer_notify_signal_exited (enum gdb_signal siggnal)
{
  struct signal_exited_args args;
  args.siggnal = siggnal;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_signal_exited() called\n");
  generic_observer_notify (signal_exited_subject, &args);
}

/* exited notifications.  */

static struct observer_list *exited_subject = NULL;

struct exited_args { int exitstatus; };

static void
observer_exited_notification_stub (const void *data, const void *args_data)
{
  observer_exited_ftype *notify = (observer_exited_ftype *) data;
  const struct exited_args *args = (const struct exited_args *) args_data;
  notify (args->exitstatus);
}

struct observer *
observer_attach_exited (observer_exited_ftype *f)
{
  return generic_observer_attach (&exited_subject,
				  &observer_exited_notification_stub,
				  (void *) f);
}

void
observer_detach_exited (struct observer *observer)
{
  generic_observer_detach (&exited_subject, observer);
}

void
observer_notify_exited (int exitstatus)
{
  struct exited_args args;
  args.exitstatus = exitstatus;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_exited() called\n");
  generic_observer_notify (exited_subject, &args);
}

/* no_history notifications.  */

static struct observer_list *no_history_subject = NULL;

static void
observer_no_history_notification_stub (const void *data, const void *args_data)
{
  observer_no_history_ftype *notify = (observer_no_history_ftype *) data;
  notify ();
}

struct observer *
observer_attach_no_history (observer_no_history_ftype *f)
{
  return generic_observer_attach (&no_history_subject,
				  &observer_no_history_notification_stub,
				  (void *) f);
}

void
observer_detach_no_history (struct observer *observer)
{
  generic_observer_detach (&no_history_subject, observer);
}

void
observer_notify_no_history (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_no_history() called\n");
  generic_observer_notify (no_history_subject, &args);
}

/* sync_execution_done notifications.  */

static struct observer_list *sync_execution_done_subject = NULL;

static void
observer_sync_execution_done_notification_stub (const void *data, const void *args_data)
{
  observer_sync_execution_done_ftype *notify = (observer_sync_execution_done_ftype *) data;
  notify ();
}

struct observer *
observer_attach_sync_execution_done (observer_sync_execution_done_ftype *f)
{
  return generic_observer_attach (&sync_execution_done_subject,
				  &observer_sync_execution_done_notification_stub,
				  (void *) f);
}

void
observer_detach_sync_execution_done (struct observer *observer)
{
  generic_observer_detach (&sync_execution_done_subject, observer);
}

void
observer_notify_sync_execution_done (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_sync_execution_done() called\n");
  generic_observer_notify (sync_execution_done_subject, &args);
}

/* command_error notifications.  */

static struct observer_list *command_error_subject = NULL;

static void
observer_command_error_notification_stub (const void *data, const void *args_data)
{
  observer_command_error_ftype *notify = (observer_command_error_ftype *) data;
  notify ();
}

struct observer *
observer_attach_command_error (observer_command_error_ftype *f)
{
  return generic_observer_attach (&command_error_subject,
				  &observer_command_error_notification_stub,
				  (void *) f);
}

void
observer_detach_command_error (struct observer *observer)
{
  generic_observer_detach (&command_error_subject, observer);
}

void
observer_notify_command_error (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_command_error() called\n");
  generic_observer_notify (command_error_subject, &args);
}

/* target_changed notifications.  */

static struct observer_list *target_changed_subject = NULL;

struct target_changed_args { struct target_ops *target; };

static void
observer_target_changed_notification_stub (const void *data, const void *args_data)
{
  observer_target_changed_ftype *notify = (observer_target_changed_ftype *) data;
  const struct target_changed_args *args = (const struct target_changed_args *) args_data;
  notify (args->target);
}

struct observer *
observer_attach_target_changed (observer_target_changed_ftype *f)
{
  return generic_observer_attach (&target_changed_subject,
				  &observer_target_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_target_changed (struct observer *observer)
{
  generic_observer_detach (&target_changed_subject, observer);
}

void
observer_notify_target_changed (struct target_ops *target)
{
  struct target_changed_args args;
  args.target = target;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_target_changed() called\n");
  generic_observer_notify (target_changed_subject, &args);
}

/* executable_changed notifications.  */

static struct observer_list *executable_changed_subject = NULL;

static void
observer_executable_changed_notification_stub (const void *data, const void *args_data)
{
  observer_executable_changed_ftype *notify = (observer_executable_changed_ftype *) data;
  notify ();
}

struct observer *
observer_attach_executable_changed (observer_executable_changed_ftype *f)
{
  return generic_observer_attach (&executable_changed_subject,
				  &observer_executable_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_executable_changed (struct observer *observer)
{
  generic_observer_detach (&executable_changed_subject, observer);
}

void
observer_notify_executable_changed (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_executable_changed() called\n");
  generic_observer_notify (executable_changed_subject, &args);
}

/* inferior_created notifications.  */

static struct observer_list *inferior_created_subject = NULL;

struct inferior_created_args { struct target_ops *objfile; int from_tty; };

static void
observer_inferior_created_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_created_ftype *notify = (observer_inferior_created_ftype *) data;
  const struct inferior_created_args *args = (const struct inferior_created_args *) args_data;
  notify (args->objfile, args->from_tty);
}

struct observer *
observer_attach_inferior_created (observer_inferior_created_ftype *f)
{
  return generic_observer_attach (&inferior_created_subject,
				  &observer_inferior_created_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_created (struct observer *observer)
{
  generic_observer_detach (&inferior_created_subject, observer);
}

void
observer_notify_inferior_created (struct target_ops *objfile, int from_tty)
{
  struct inferior_created_args args;
  args.objfile = objfile, args.from_tty = from_tty;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_created() called\n");
  generic_observer_notify (inferior_created_subject, &args);
}

/* record_changed notifications.  */

static struct observer_list *record_changed_subject = NULL;

struct record_changed_args { struct inferior *inferior; int started; const char *method; const char *format; };

static void
observer_record_changed_notification_stub (const void *data, const void *args_data)
{
  observer_record_changed_ftype *notify = (observer_record_changed_ftype *) data;
  const struct record_changed_args *args = (const struct record_changed_args *) args_data;
  notify (args->inferior, args->started, args->method, args->format);
}

struct observer *
observer_attach_record_changed (observer_record_changed_ftype *f)
{
  return generic_observer_attach (&record_changed_subject,
				  &observer_record_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_record_changed (struct observer *observer)
{
  generic_observer_detach (&record_changed_subject, observer);
}

void
observer_notify_record_changed (struct inferior *inferior, int started, const char *method, const char *format)
{
  struct record_changed_args args;
  args.inferior = inferior, args.started = started, args.method = method, args.format = format;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_record_changed() called\n");
  generic_observer_notify (record_changed_subject, &args);
}

/* solib_loaded notifications.  */

static struct observer_list *solib_loaded_subject = NULL;

struct solib_loaded_args { struct so_list *solib; };

static void
observer_solib_loaded_notification_stub (const void *data, const void *args_data)
{
  observer_solib_loaded_ftype *notify = (observer_solib_loaded_ftype *) data;
  const struct solib_loaded_args *args = (const struct solib_loaded_args *) args_data;
  notify (args->solib);
}

struct observer *
observer_attach_solib_loaded (observer_solib_loaded_ftype *f)
{
  return generic_observer_attach (&solib_loaded_subject,
				  &observer_solib_loaded_notification_stub,
				  (void *) f);
}

void
observer_detach_solib_loaded (struct observer *observer)
{
  generic_observer_detach (&solib_loaded_subject, observer);
}

void
observer_notify_solib_loaded (struct so_list *solib)
{
  struct solib_loaded_args args;
  args.solib = solib;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_solib_loaded() called\n");
  generic_observer_notify (solib_loaded_subject, &args);
}

/* solib_unloaded notifications.  */

static struct observer_list *solib_unloaded_subject = NULL;

struct solib_unloaded_args { struct so_list *solib; };

static void
observer_solib_unloaded_notification_stub (const void *data, const void *args_data)
{
  observer_solib_unloaded_ftype *notify = (observer_solib_unloaded_ftype *) data;
  const struct solib_unloaded_args *args = (const struct solib_unloaded_args *) args_data;
  notify (args->solib);
}

struct observer *
observer_attach_solib_unloaded (observer_solib_unloaded_ftype *f)
{
  return generic_observer_attach (&solib_unloaded_subject,
				  &observer_solib_unloaded_notification_stub,
				  (void *) f);
}

void
observer_detach_solib_unloaded (struct observer *observer)
{
  generic_observer_detach (&solib_unloaded_subject, observer);
}

void
observer_notify_solib_unloaded (struct so_list *solib)
{
  struct solib_unloaded_args args;
  args.solib = solib;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_solib_unloaded() called\n");
  generic_observer_notify (solib_unloaded_subject, &args);
}

/* new_objfile notifications.  */

static struct observer_list *new_objfile_subject = NULL;

struct new_objfile_args { struct objfile *objfile; };

static void
observer_new_objfile_notification_stub (const void *data, const void *args_data)
{
  observer_new_objfile_ftype *notify = (observer_new_objfile_ftype *) data;
  const struct new_objfile_args *args = (const struct new_objfile_args *) args_data;
  notify (args->objfile);
}

struct observer *
observer_attach_new_objfile (observer_new_objfile_ftype *f)
{
  return generic_observer_attach (&new_objfile_subject,
				  &observer_new_objfile_notification_stub,
				  (void *) f);
}

void
observer_detach_new_objfile (struct observer *observer)
{
  generic_observer_detach (&new_objfile_subject, observer);
}

void
observer_notify_new_objfile (struct objfile *objfile)
{
  struct new_objfile_args args;
  args.objfile = objfile;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_new_objfile() called\n");
  generic_observer_notify (new_objfile_subject, &args);
}

/* free_objfile notifications.  */

static struct observer_list *free_objfile_subject = NULL;

struct free_objfile_args { struct objfile *objfile; };

static void
observer_free_objfile_notification_stub (const void *data, const void *args_data)
{
  observer_free_objfile_ftype *notify = (observer_free_objfile_ftype *) data;
  const struct free_objfile_args *args = (const struct free_objfile_args *) args_data;
  notify (args->objfile);
}

struct observer *
observer_attach_free_objfile (observer_free_objfile_ftype *f)
{
  return generic_observer_attach (&free_objfile_subject,
				  &observer_free_objfile_notification_stub,
				  (void *) f);
}

void
observer_detach_free_objfile (struct observer *observer)
{
  generic_observer_detach (&free_objfile_subject, observer);
}

void
observer_notify_free_objfile (struct objfile *objfile)
{
  struct free_objfile_args args;
  args.objfile = objfile;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_free_objfile() called\n");
  generic_observer_notify (free_objfile_subject, &args);
}

/* new_thread notifications.  */

static struct observer_list *new_thread_subject = NULL;

struct new_thread_args { struct thread_info *t; };

static void
observer_new_thread_notification_stub (const void *data, const void *args_data)
{
  observer_new_thread_ftype *notify = (observer_new_thread_ftype *) data;
  const struct new_thread_args *args = (const struct new_thread_args *) args_data;
  notify (args->t);
}

struct observer *
observer_attach_new_thread (observer_new_thread_ftype *f)
{
  return generic_observer_attach (&new_thread_subject,
				  &observer_new_thread_notification_stub,
				  (void *) f);
}

void
observer_detach_new_thread (struct observer *observer)
{
  generic_observer_detach (&new_thread_subject, observer);
}

void
observer_notify_new_thread (struct thread_info *t)
{
  struct new_thread_args args;
  args.t = t;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_new_thread() called\n");
  generic_observer_notify (new_thread_subject, &args);
}

/* thread_exit notifications.  */

static struct observer_list *thread_exit_subject = NULL;

struct thread_exit_args { struct thread_info *t; int silent; };

static void
observer_thread_exit_notification_stub (const void *data, const void *args_data)
{
  observer_thread_exit_ftype *notify = (observer_thread_exit_ftype *) data;
  const struct thread_exit_args *args = (const struct thread_exit_args *) args_data;
  notify (args->t, args->silent);
}

struct observer *
observer_attach_thread_exit (observer_thread_exit_ftype *f)
{
  return generic_observer_attach (&thread_exit_subject,
				  &observer_thread_exit_notification_stub,
				  (void *) f);
}

void
observer_detach_thread_exit (struct observer *observer)
{
  generic_observer_detach (&thread_exit_subject, observer);
}

void
observer_notify_thread_exit (struct thread_info *t, int silent)
{
  struct thread_exit_args args;
  args.t = t, args.silent = silent;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_exit() called\n");
  generic_observer_notify (thread_exit_subject, &args);
}

/* thread_stop_requested notifications.  */

static struct observer_list *thread_stop_requested_subject = NULL;

struct thread_stop_requested_args { ptid_t ptid; };

static void
observer_thread_stop_requested_notification_stub (const void *data, const void *args_data)
{
  observer_thread_stop_requested_ftype *notify = (observer_thread_stop_requested_ftype *) data;
  const struct thread_stop_requested_args *args = (const struct thread_stop_requested_args *) args_data;
  notify (args->ptid);
}

struct observer *
observer_attach_thread_stop_requested (observer_thread_stop_requested_ftype *f)
{
  return generic_observer_attach (&thread_stop_requested_subject,
				  &observer_thread_stop_requested_notification_stub,
				  (void *) f);
}

void
observer_detach_thread_stop_requested (struct observer *observer)
{
  generic_observer_detach (&thread_stop_requested_subject, observer);
}

void
observer_notify_thread_stop_requested (ptid_t ptid)
{
  struct thread_stop_requested_args args;
  args.ptid = ptid;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_stop_requested() called\n");
  generic_observer_notify (thread_stop_requested_subject, &args);
}

/* target_resumed notifications.  */

static struct observer_list *target_resumed_subject = NULL;

struct target_resumed_args { ptid_t ptid; };

static void
observer_target_resumed_notification_stub (const void *data, const void *args_data)
{
  observer_target_resumed_ftype *notify = (observer_target_resumed_ftype *) data;
  const struct target_resumed_args *args = (const struct target_resumed_args *) args_data;
  notify (args->ptid);
}

struct observer *
observer_attach_target_resumed (observer_target_resumed_ftype *f)
{
  return generic_observer_attach (&target_resumed_subject,
				  &observer_target_resumed_notification_stub,
				  (void *) f);
}

void
observer_detach_target_resumed (struct observer *observer)
{
  generic_observer_detach (&target_resumed_subject, observer);
}

void
observer_notify_target_resumed (ptid_t ptid)
{
  struct target_resumed_args args;
  args.ptid = ptid;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_target_resumed() called\n");
  generic_observer_notify (target_resumed_subject, &args);
}

/* about_to_proceed notifications.  */

static struct observer_list *about_to_proceed_subject = NULL;

static void
observer_about_to_proceed_notification_stub (const void *data, const void *args_data)
{
  observer_about_to_proceed_ftype *notify = (observer_about_to_proceed_ftype *) data;
  notify ();
}

struct observer *
observer_attach_about_to_proceed (observer_about_to_proceed_ftype *f)
{
  return generic_observer_attach (&about_to_proceed_subject,
				  &observer_about_to_proceed_notification_stub,
				  (void *) f);
}

void
observer_detach_about_to_proceed (struct observer *observer)
{
  generic_observer_detach (&about_to_proceed_subject, observer);
}

void
observer_notify_about_to_proceed (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_about_to_proceed() called\n");
  generic_observer_notify (about_to_proceed_subject, &args);
}

/* breakpoint_created notifications.  */

static struct observer_list *breakpoint_created_subject = NULL;

struct breakpoint_created_args { struct breakpoint *b; };

static void
observer_breakpoint_created_notification_stub (const void *data, const void *args_data)
{
  observer_breakpoint_created_ftype *notify = (observer_breakpoint_created_ftype *) data;
  const struct breakpoint_created_args *args = (const struct breakpoint_created_args *) args_data;
  notify (args->b);
}

struct observer *
observer_attach_breakpoint_created (observer_breakpoint_created_ftype *f)
{
  return generic_observer_attach (&breakpoint_created_subject,
				  &observer_breakpoint_created_notification_stub,
				  (void *) f);
}

void
observer_detach_breakpoint_created (struct observer *observer)
{
  generic_observer_detach (&breakpoint_created_subject, observer);
}

void
observer_notify_breakpoint_created (struct breakpoint *b)
{
  struct breakpoint_created_args args;
  args.b = b;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_created() called\n");
  generic_observer_notify (breakpoint_created_subject, &args);
}

/* breakpoint_deleted notifications.  */

static struct observer_list *breakpoint_deleted_subject = NULL;

struct breakpoint_deleted_args { struct breakpoint *b; };

static void
observer_breakpoint_deleted_notification_stub (const void *data, const void *args_data)
{
  observer_breakpoint_deleted_ftype *notify = (observer_breakpoint_deleted_ftype *) data;
  const struct breakpoint_deleted_args *args = (const struct breakpoint_deleted_args *) args_data;
  notify (args->b);
}

struct observer *
observer_attach_breakpoint_deleted (observer_breakpoint_deleted_ftype *f)
{
  return generic_observer_attach (&breakpoint_deleted_subject,
				  &observer_breakpoint_deleted_notification_stub,
				  (void *) f);
}

void
observer_detach_breakpoint_deleted (struct observer *observer)
{
  generic_observer_detach (&breakpoint_deleted_subject, observer);
}

void
observer_notify_breakpoint_deleted (struct breakpoint *b)
{
  struct breakpoint_deleted_args args;
  args.b = b;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_deleted() called\n");
  generic_observer_notify (breakpoint_deleted_subject, &args);
}

/* breakpoint_modified notifications.  */

static struct observer_list *breakpoint_modified_subject = NULL;

struct breakpoint_modified_args { struct breakpoint *b; };

static void
observer_breakpoint_modified_notification_stub (const void *data, const void *args_data)
{
  observer_breakpoint_modified_ftype *notify = (observer_breakpoint_modified_ftype *) data;
  const struct breakpoint_modified_args *args = (const struct breakpoint_modified_args *) args_data;
  notify (args->b);
}

struct observer *
observer_attach_breakpoint_modified (observer_breakpoint_modified_ftype *f)
{
  return generic_observer_attach (&breakpoint_modified_subject,
				  &observer_breakpoint_modified_notification_stub,
				  (void *) f);
}

void
observer_detach_breakpoint_modified (struct observer *observer)
{
  generic_observer_detach (&breakpoint_modified_subject, observer);
}

void
observer_notify_breakpoint_modified (struct breakpoint *b)
{
  struct breakpoint_modified_args args;
  args.b = b;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_breakpoint_modified() called\n");
  generic_observer_notify (breakpoint_modified_subject, &args);
}

/* traceframe_changed notifications.  */

static struct observer_list *traceframe_changed_subject = NULL;

struct traceframe_changed_args { int tfnum; int tpnum; };

static void
observer_traceframe_changed_notification_stub (const void *data, const void *args_data)
{
  observer_traceframe_changed_ftype *notify = (observer_traceframe_changed_ftype *) data;
  const struct traceframe_changed_args *args = (const struct traceframe_changed_args *) args_data;
  notify (args->tfnum, args->tpnum);
}

struct observer *
observer_attach_traceframe_changed (observer_traceframe_changed_ftype *f)
{
  return generic_observer_attach (&traceframe_changed_subject,
				  &observer_traceframe_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_traceframe_changed (struct observer *observer)
{
  generic_observer_detach (&traceframe_changed_subject, observer);
}

void
observer_notify_traceframe_changed (int tfnum, int tpnum)
{
  struct traceframe_changed_args args;
  args.tfnum = tfnum, args.tpnum = tpnum;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_traceframe_changed() called\n");
  generic_observer_notify (traceframe_changed_subject, &args);
}

/* architecture_changed notifications.  */

static struct observer_list *architecture_changed_subject = NULL;

struct architecture_changed_args { struct gdbarch *newarch; };

static void
observer_architecture_changed_notification_stub (const void *data, const void *args_data)
{
  observer_architecture_changed_ftype *notify = (observer_architecture_changed_ftype *) data;
  const struct architecture_changed_args *args = (const struct architecture_changed_args *) args_data;
  notify (args->newarch);
}

struct observer *
observer_attach_architecture_changed (observer_architecture_changed_ftype *f)
{
  return generic_observer_attach (&architecture_changed_subject,
				  &observer_architecture_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_architecture_changed (struct observer *observer)
{
  generic_observer_detach (&architecture_changed_subject, observer);
}

void
observer_notify_architecture_changed (struct gdbarch *newarch)
{
  struct architecture_changed_args args;
  args.newarch = newarch;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_architecture_changed() called\n");
  generic_observer_notify (architecture_changed_subject, &args);
}

/* thread_ptid_changed notifications.  */

static struct observer_list *thread_ptid_changed_subject = NULL;

struct thread_ptid_changed_args { ptid_t old_ptid; ptid_t new_ptid; };

static void
observer_thread_ptid_changed_notification_stub (const void *data, const void *args_data)
{
  observer_thread_ptid_changed_ftype *notify = (observer_thread_ptid_changed_ftype *) data;
  const struct thread_ptid_changed_args *args = (const struct thread_ptid_changed_args *) args_data;
  notify (args->old_ptid, args->new_ptid);
}

struct observer *
observer_attach_thread_ptid_changed (observer_thread_ptid_changed_ftype *f)
{
  return generic_observer_attach (&thread_ptid_changed_subject,
				  &observer_thread_ptid_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_thread_ptid_changed (struct observer *observer)
{
  generic_observer_detach (&thread_ptid_changed_subject, observer);
}

void
observer_notify_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
{
  struct thread_ptid_changed_args args;
  args.old_ptid = old_ptid, args.new_ptid = new_ptid;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_thread_ptid_changed() called\n");
  generic_observer_notify (thread_ptid_changed_subject, &args);
}

/* inferior_added notifications.  */

static struct observer_list *inferior_added_subject = NULL;

struct inferior_added_args { struct inferior *inf; };

static void
observer_inferior_added_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_added_ftype *notify = (observer_inferior_added_ftype *) data;
  const struct inferior_added_args *args = (const struct inferior_added_args *) args_data;
  notify (args->inf);
}

struct observer *
observer_attach_inferior_added (observer_inferior_added_ftype *f)
{
  return generic_observer_attach (&inferior_added_subject,
				  &observer_inferior_added_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_added (struct observer *observer)
{
  generic_observer_detach (&inferior_added_subject, observer);
}

void
observer_notify_inferior_added (struct inferior *inf)
{
  struct inferior_added_args args;
  args.inf = inf;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_added() called\n");
  generic_observer_notify (inferior_added_subject, &args);
}

/* inferior_appeared notifications.  */

static struct observer_list *inferior_appeared_subject = NULL;

struct inferior_appeared_args { struct inferior *inf; };

static void
observer_inferior_appeared_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_appeared_ftype *notify = (observer_inferior_appeared_ftype *) data;
  const struct inferior_appeared_args *args = (const struct inferior_appeared_args *) args_data;
  notify (args->inf);
}

struct observer *
observer_attach_inferior_appeared (observer_inferior_appeared_ftype *f)
{
  return generic_observer_attach (&inferior_appeared_subject,
				  &observer_inferior_appeared_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_appeared (struct observer *observer)
{
  generic_observer_detach (&inferior_appeared_subject, observer);
}

void
observer_notify_inferior_appeared (struct inferior *inf)
{
  struct inferior_appeared_args args;
  args.inf = inf;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_appeared() called\n");
  generic_observer_notify (inferior_appeared_subject, &args);
}

/* inferior_exit notifications.  */

static struct observer_list *inferior_exit_subject = NULL;

struct inferior_exit_args { struct inferior *inf; };

static void
observer_inferior_exit_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_exit_ftype *notify = (observer_inferior_exit_ftype *) data;
  const struct inferior_exit_args *args = (const struct inferior_exit_args *) args_data;
  notify (args->inf);
}

struct observer *
observer_attach_inferior_exit (observer_inferior_exit_ftype *f)
{
  return generic_observer_attach (&inferior_exit_subject,
				  &observer_inferior_exit_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_exit (struct observer *observer)
{
  generic_observer_detach (&inferior_exit_subject, observer);
}

void
observer_notify_inferior_exit (struct inferior *inf)
{
  struct inferior_exit_args args;
  args.inf = inf;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_exit() called\n");
  generic_observer_notify (inferior_exit_subject, &args);
}

/* inferior_removed notifications.  */

static struct observer_list *inferior_removed_subject = NULL;

struct inferior_removed_args { struct inferior *inf; };

static void
observer_inferior_removed_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_removed_ftype *notify = (observer_inferior_removed_ftype *) data;
  const struct inferior_removed_args *args = (const struct inferior_removed_args *) args_data;
  notify (args->inf);
}

struct observer *
observer_attach_inferior_removed (observer_inferior_removed_ftype *f)
{
  return generic_observer_attach (&inferior_removed_subject,
				  &observer_inferior_removed_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_removed (struct observer *observer)
{
  generic_observer_detach (&inferior_removed_subject, observer);
}

void
observer_notify_inferior_removed (struct inferior *inf)
{
  struct inferior_removed_args args;
  args.inf = inf;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_removed() called\n");
  generic_observer_notify (inferior_removed_subject, &args);
}

/* memory_changed notifications.  */

static struct observer_list *memory_changed_subject = NULL;

struct memory_changed_args { struct inferior *inferior; CORE_ADDR addr; ssize_t len; const bfd_byte *data; };

static void
observer_memory_changed_notification_stub (const void *data, const void *args_data)
{
  observer_memory_changed_ftype *notify = (observer_memory_changed_ftype *) data;
  const struct memory_changed_args *args = (const struct memory_changed_args *) args_data;
  notify (args->inferior, args->addr, args->len, args->data);
}

struct observer *
observer_attach_memory_changed (observer_memory_changed_ftype *f)
{
  return generic_observer_attach (&memory_changed_subject,
				  &observer_memory_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_memory_changed (struct observer *observer)
{
  generic_observer_detach (&memory_changed_subject, observer);
}

void
observer_notify_memory_changed (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
{
  struct memory_changed_args args;
  args.inferior = inferior, args.addr = addr, args.len = len, args.data = data;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_memory_changed() called\n");
  generic_observer_notify (memory_changed_subject, &args);
}

/* before_prompt notifications.  */

static struct observer_list *before_prompt_subject = NULL;

struct before_prompt_args { const char *current_prompt; };

static void
observer_before_prompt_notification_stub (const void *data, const void *args_data)
{
  observer_before_prompt_ftype *notify = (observer_before_prompt_ftype *) data;
  const struct before_prompt_args *args = (const struct before_prompt_args *) args_data;
  notify (args->current_prompt);
}

struct observer *
observer_attach_before_prompt (observer_before_prompt_ftype *f)
{
  return generic_observer_attach (&before_prompt_subject,
				  &observer_before_prompt_notification_stub,
				  (void *) f);
}

void
observer_detach_before_prompt (struct observer *observer)
{
  generic_observer_detach (&before_prompt_subject, observer);
}

void
observer_notify_before_prompt (const char *current_prompt)
{
  struct before_prompt_args args;
  args.current_prompt = current_prompt;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_before_prompt() called\n");
  generic_observer_notify (before_prompt_subject, &args);
}

/* gdb_datadir_changed notifications.  */

static struct observer_list *gdb_datadir_changed_subject = NULL;

static void
observer_gdb_datadir_changed_notification_stub (const void *data, const void *args_data)
{
  observer_gdb_datadir_changed_ftype *notify = (observer_gdb_datadir_changed_ftype *) data;
  notify ();
}

struct observer *
observer_attach_gdb_datadir_changed (observer_gdb_datadir_changed_ftype *f)
{
  return generic_observer_attach (&gdb_datadir_changed_subject,
				  &observer_gdb_datadir_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_gdb_datadir_changed (struct observer *observer)
{
  generic_observer_detach (&gdb_datadir_changed_subject, observer);
}

void
observer_notify_gdb_datadir_changed (void)
{
char *args = NULL;
  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_gdb_datadir_changed() called\n");
  generic_observer_notify (gdb_datadir_changed_subject, &args);
}

/* command_param_changed notifications.  */

static struct observer_list *command_param_changed_subject = NULL;

struct command_param_changed_args { const char *param; const char *value; };

static void
observer_command_param_changed_notification_stub (const void *data, const void *args_data)
{
  observer_command_param_changed_ftype *notify = (observer_command_param_changed_ftype *) data;
  const struct command_param_changed_args *args = (const struct command_param_changed_args *) args_data;
  notify (args->param, args->value);
}

struct observer *
observer_attach_command_param_changed (observer_command_param_changed_ftype *f)
{
  return generic_observer_attach (&command_param_changed_subject,
				  &observer_command_param_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_command_param_changed (struct observer *observer)
{
  generic_observer_detach (&command_param_changed_subject, observer);
}

void
observer_notify_command_param_changed (const char *param, const char *value)
{
  struct command_param_changed_args args;
  args.param = param, args.value = value;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_command_param_changed() called\n");
  generic_observer_notify (command_param_changed_subject, &args);
}

/* tsv_created notifications.  */

static struct observer_list *tsv_created_subject = NULL;

struct tsv_created_args { const struct trace_state_variable *tsv; };

static void
observer_tsv_created_notification_stub (const void *data, const void *args_data)
{
  observer_tsv_created_ftype *notify = (observer_tsv_created_ftype *) data;
  const struct tsv_created_args *args = (const struct tsv_created_args *) args_data;
  notify (args->tsv);
}

struct observer *
observer_attach_tsv_created (observer_tsv_created_ftype *f)
{
  return generic_observer_attach (&tsv_created_subject,
				  &observer_tsv_created_notification_stub,
				  (void *) f);
}

void
observer_detach_tsv_created (struct observer *observer)
{
  generic_observer_detach (&tsv_created_subject, observer);
}

void
observer_notify_tsv_created (const struct trace_state_variable *tsv)
{
  struct tsv_created_args args;
  args.tsv = tsv;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_created() called\n");
  generic_observer_notify (tsv_created_subject, &args);
}

/* tsv_deleted notifications.  */

static struct observer_list *tsv_deleted_subject = NULL;

struct tsv_deleted_args { const struct trace_state_variable *tsv; };

static void
observer_tsv_deleted_notification_stub (const void *data, const void *args_data)
{
  observer_tsv_deleted_ftype *notify = (observer_tsv_deleted_ftype *) data;
  const struct tsv_deleted_args *args = (const struct tsv_deleted_args *) args_data;
  notify (args->tsv);
}

struct observer *
observer_attach_tsv_deleted (observer_tsv_deleted_ftype *f)
{
  return generic_observer_attach (&tsv_deleted_subject,
				  &observer_tsv_deleted_notification_stub,
				  (void *) f);
}

void
observer_detach_tsv_deleted (struct observer *observer)
{
  generic_observer_detach (&tsv_deleted_subject, observer);
}

void
observer_notify_tsv_deleted (const struct trace_state_variable *tsv)
{
  struct tsv_deleted_args args;
  args.tsv = tsv;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_deleted() called\n");
  generic_observer_notify (tsv_deleted_subject, &args);
}

/* tsv_modified notifications.  */

static struct observer_list *tsv_modified_subject = NULL;

struct tsv_modified_args { const struct trace_state_variable *tsv; };

static void
observer_tsv_modified_notification_stub (const void *data, const void *args_data)
{
  observer_tsv_modified_ftype *notify = (observer_tsv_modified_ftype *) data;
  const struct tsv_modified_args *args = (const struct tsv_modified_args *) args_data;
  notify (args->tsv);
}

struct observer *
observer_attach_tsv_modified (observer_tsv_modified_ftype *f)
{
  return generic_observer_attach (&tsv_modified_subject,
				  &observer_tsv_modified_notification_stub,
				  (void *) f);
}

void
observer_detach_tsv_modified (struct observer *observer)
{
  generic_observer_detach (&tsv_modified_subject, observer);
}

void
observer_notify_tsv_modified (const struct trace_state_variable *tsv)
{
  struct tsv_modified_args args;
  args.tsv = tsv;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_tsv_modified() called\n");
  generic_observer_notify (tsv_modified_subject, &args);
}

/* inferior_call_pre notifications.  */

static struct observer_list *inferior_call_pre_subject = NULL;

struct inferior_call_pre_args { ptid_t thread; CORE_ADDR address; };

static void
observer_inferior_call_pre_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_call_pre_ftype *notify = (observer_inferior_call_pre_ftype *) data;
  const struct inferior_call_pre_args *args = (const struct inferior_call_pre_args *) args_data;
  notify (args->thread, args->address);
}

struct observer *
observer_attach_inferior_call_pre (observer_inferior_call_pre_ftype *f)
{
  return generic_observer_attach (&inferior_call_pre_subject,
				  &observer_inferior_call_pre_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_call_pre (struct observer *observer)
{
  generic_observer_detach (&inferior_call_pre_subject, observer);
}

void
observer_notify_inferior_call_pre (ptid_t thread, CORE_ADDR address)
{
  struct inferior_call_pre_args args;
  args.thread = thread, args.address = address;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_call_pre() called\n");
  generic_observer_notify (inferior_call_pre_subject, &args);
}

/* inferior_call_post notifications.  */

static struct observer_list *inferior_call_post_subject = NULL;

struct inferior_call_post_args { ptid_t thread; CORE_ADDR address; };

static void
observer_inferior_call_post_notification_stub (const void *data, const void *args_data)
{
  observer_inferior_call_post_ftype *notify = (observer_inferior_call_post_ftype *) data;
  const struct inferior_call_post_args *args = (const struct inferior_call_post_args *) args_data;
  notify (args->thread, args->address);
}

struct observer *
observer_attach_inferior_call_post (observer_inferior_call_post_ftype *f)
{
  return generic_observer_attach (&inferior_call_post_subject,
				  &observer_inferior_call_post_notification_stub,
				  (void *) f);
}

void
observer_detach_inferior_call_post (struct observer *observer)
{
  generic_observer_detach (&inferior_call_post_subject, observer);
}

void
observer_notify_inferior_call_post (ptid_t thread, CORE_ADDR address)
{
  struct inferior_call_post_args args;
  args.thread = thread, args.address = address;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_inferior_call_post() called\n");
  generic_observer_notify (inferior_call_post_subject, &args);
}

/* register_changed notifications.  */

static struct observer_list *register_changed_subject = NULL;

struct register_changed_args { struct frame_info *frame; int regnum; };

static void
observer_register_changed_notification_stub (const void *data, const void *args_data)
{
  observer_register_changed_ftype *notify = (observer_register_changed_ftype *) data;
  const struct register_changed_args *args = (const struct register_changed_args *) args_data;
  notify (args->frame, args->regnum);
}

struct observer *
observer_attach_register_changed (observer_register_changed_ftype *f)
{
  return generic_observer_attach (&register_changed_subject,
				  &observer_register_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_register_changed (struct observer *observer)
{
  generic_observer_detach (&register_changed_subject, observer);
}

void
observer_notify_register_changed (struct frame_info *frame, int regnum)
{
  struct register_changed_args args;
  args.frame = frame, args.regnum = regnum;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_register_changed() called\n");
  generic_observer_notify (register_changed_subject, &args);
}

/* test_notification notifications.  */

static struct observer_list *test_notification_subject = NULL;

struct test_notification_args { int somearg; };

static void
observer_test_notification_notification_stub (const void *data, const void *args_data)
{
  observer_test_notification_ftype *notify = (observer_test_notification_ftype *) data;
  const struct test_notification_args *args = (const struct test_notification_args *) args_data;
  notify (args->somearg);
}

struct observer *
observer_attach_test_notification (observer_test_notification_ftype *f)
{
  return generic_observer_attach (&test_notification_subject,
				  &observer_test_notification_notification_stub,
				  (void *) f);
}

void
observer_detach_test_notification (struct observer *observer)
{
  generic_observer_detach (&test_notification_subject, observer);
}

void
observer_notify_test_notification (int somearg)
{
  struct test_notification_args args;
  args.somearg = somearg;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_test_notification() called\n");
  generic_observer_notify (test_notification_subject, &args);
}

/* user_selected_context_changed notifications.  */

static struct observer_list *user_selected_context_changed_subject = NULL;

struct user_selected_context_changed_args { user_selected_what selection; };

static void
observer_user_selected_context_changed_notification_stub (const void *data, const void *args_data)
{
  observer_user_selected_context_changed_ftype *notify = (observer_user_selected_context_changed_ftype *) data;
  const struct user_selected_context_changed_args *args = (const struct user_selected_context_changed_args *) args_data;
  notify (args->selection);
}

struct observer *
observer_attach_user_selected_context_changed (observer_user_selected_context_changed_ftype *f)
{
  return generic_observer_attach (&user_selected_context_changed_subject,
				  &observer_user_selected_context_changed_notification_stub,
				  (void *) f);
}

void
observer_detach_user_selected_context_changed (struct observer *observer)
{
  generic_observer_detach (&user_selected_context_changed_subject, observer);
}

void
observer_notify_user_selected_context_changed (user_selected_what selection)
{
  struct user_selected_context_changed_args args;
  args.selection = selection;

  if (observer_debug)
    fprintf_unfiltered (gdb_stdlog, "observer_notify_user_selected_context_changed() called\n");
  generic_observer_notify (user_selected_context_changed_subject, &args);
}