extern int child_suppress_run;
extern struct target_ops child_ops; /* target vector for inftarg.c */
-extern void _initialize_hpux_thread PARAMS ((void));
+extern void _initialize_hpux_thread (void);
struct string_map
{
static CORE_ADDR P_cma__g_known_threads;
static CORE_ADDR P_cma__g_current_thread;
-static struct cleanup *save_inferior_pid PARAMS ((void));
+static struct cleanup *save_inferior_pid (void);
-static void restore_inferior_pid PARAMS ((int pid));
+static void restore_inferior_pid (int pid);
-static void hpux_thread_resume PARAMS ((int pid, int step,
- enum target_signal signo));
+static void hpux_thread_resume (int pid, int step, enum target_signal signo);
-static void init_hpux_thread_ops PARAMS ((void));
+static void init_hpux_thread_ops (void);
static struct target_ops hpux_thread_ops;
\f
static struct cleanup *
-save_inferior_pid ()
+save_inferior_pid (void)
{
return make_cleanup (restore_inferior_pid, inferior_pid);
}
static void
-restore_inferior_pid (pid)
- int pid;
+restore_inferior_pid (int pid)
{
inferior_pid = pid;
}
\f
-static int find_active_thread PARAMS ((void));
+static int find_active_thread (void);
static int cached_thread;
static int cached_active_thread;
static cma__t_int_tcb cached_tcb;
static int
-find_active_thread ()
+find_active_thread (void)
{
static cma__t_int_tcb tcb;
CORE_ADDR tcb_ptr;
return (cma_thread_get_unique (&tcb.prolog.client_thread) << 16) | main_pid;
}
-static cma__t_int_tcb *find_tcb PARAMS ((int thread));
+static cma__t_int_tcb *find_tcb (int thread);
static cma__t_int_tcb *
-find_tcb (thread)
- int thread;
+find_tcb (int thread)
{
cma__t_known_object queue_header;
cma__t_queue *queue_ptr;
/* ARGSUSED */
static void
-hpux_thread_open (arg, from_tty)
- char *arg;
- int from_tty;
+hpux_thread_open (char *arg, int from_tty)
{
child_ops.to_open (arg, from_tty);
}
and wait for the trace-trap that results from attaching. */
static void
-hpux_thread_attach (args, from_tty)
- char *args;
- int from_tty;
+hpux_thread_attach (char *args, int from_tty)
{
child_ops.to_attach (args, from_tty);
started via the normal ptrace (PTRACE_TRACEME). */
static void
-hpux_thread_detach (args, from_tty)
- char *args;
- int from_tty;
+hpux_thread_detach (char *args, int from_tty)
{
child_ops.to_detach (args, from_tty);
}
for procfs. */
static void
-hpux_thread_resume (pid, step, signo)
- int pid;
- int step;
- enum target_signal signo;
+hpux_thread_resume (int pid, int step, enum target_signal signo)
{
struct cleanup *old_chain;
to a LWP id, and vice versa on the way out. */
static int
-hpux_thread_wait (pid, ourstatus)
- int pid;
- struct target_waitstatus *ourstatus;
+hpux_thread_wait (int pid, struct target_waitstatus *ourstatus)
{
int rtnval;
struct cleanup *old_chain;
};
static void
-hpux_thread_fetch_registers (regno)
- int regno;
+hpux_thread_fetch_registers (int regno)
{
cma__t_int_tcb tcb, *tcb_ptr;
struct cleanup *old_chain;
}
static void
-hpux_thread_store_registers (regno)
- int regno;
+hpux_thread_store_registers (int regno)
{
cma__t_int_tcb tcb, *tcb_ptr;
struct cleanup *old_chain;
debugged. */
static void
-hpux_thread_prepare_to_store ()
+hpux_thread_prepare_to_store (void)
{
child_ops.to_prepare_to_store ();
}
static int
-hpux_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int dowrite;
- struct target_ops *target; /* ignored */
+hpux_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int dowrite, struct target_ops *target)
{
int retval;
struct cleanup *old_chain;
/* Print status information about what we're accessing. */
static void
-hpux_thread_files_info (ignore)
- struct target_ops *ignore;
+hpux_thread_files_info (struct target_ops *ignore)
{
child_ops.to_files_info (ignore);
}
static void
-hpux_thread_kill_inferior ()
+hpux_thread_kill_inferior (void)
{
child_ops.to_kill ();
}
static void
-hpux_thread_notice_signals (pid)
- int pid;
+hpux_thread_notice_signals (int pid)
{
child_ops.to_notice_signals (pid);
}
/* Fork an inferior process, and start debugging it with /proc. */
static void
-hpux_thread_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
+hpux_thread_create_inferior (char *exec_file, char *allargs, char **env)
{
child_ops.to_create_inferior (exec_file, allargs, env);
*/
/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) PARAMS ((struct objfile *));
+static void (*target_new_objfile_chain) (struct objfile *);
void
-hpux_thread_new_objfile (objfile)
- struct objfile *objfile;
+hpux_thread_new_objfile (struct objfile *objfile)
{
struct minimal_symbol *ms;
/* Clean up after the inferior dies. */
static void
-hpux_thread_mourn_inferior ()
+hpux_thread_mourn_inferior (void)
{
child_ops.to_mourn_inferior ();
}
/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
static int
-hpux_thread_can_run ()
+hpux_thread_can_run (void)
{
return child_suppress_run;
}
static int
-hpux_thread_alive (pid)
- int pid;
+hpux_thread_alive (int pid)
{
return 1;
}
static void
-hpux_thread_stop ()
+hpux_thread_stop (void)
{
child_ops.to_stop ();
}
/* Convert a pid to printable form. */
char *
-hpux_pid_to_str (pid)
- int pid;
+hpux_pid_to_str (int pid)
{
static char buf[100];
}
\f
static void
-init_hpux_thread_ops ()
+init_hpux_thread_ops (void)
{
hpux_thread_ops.to_shortname = "hpux-threads";
hpux_thread_ops.to_longname = "HPUX threads and pthread.";
}
void
-_initialize_hpux_thread ()
+_initialize_hpux_thread (void)
{
init_hpux_thread_ops ();
add_target (&hpux_thread_ops);