/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
- Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/stat.h>
#include <dlfcn.h>
#include "gdbcmd.h"
+#include "gdbcore.h"
extern struct target_ops sol_thread_ops; /* Forward declaration */
extern struct target_ops sol_core_ops; /* Forward declaration */
extern int procfs_suppress_run;
extern struct target_ops procfs_ops; /* target vector for procfs.c */
extern struct target_ops core_ops; /* target vector for corelow.c */
-extern char *procfs_pid_to_str PARAMS ((int pid));
-
-/* Note that these prototypes differ slightly from those used in procfs.c
- for of two reasons. One, we can't use gregset_t, as that's got a whole
- different meaning under Solaris (also, see above). Two, we can't use the
- pointer form here as these are actually arrays of ints (for Sparc's at
- least), and are automatically coerced into pointers to ints when used as
- parameters. That makes it impossible to avoid a compiler warning when
- passing pr{g fp}regset_t's from a parameter to an argument of one of
- these functions. */
-
-extern void supply_gregset PARAMS ((const prgregset_t));
-extern void fill_gregset PARAMS ((prgregset_t, int));
-extern void supply_fpregset PARAMS ((const prfpregset_t *));
-extern void fill_fpregset PARAMS ((prfpregset_t *, int));
+extern char *procfs_pid_to_str (int pid);
+
+/* Prototypes for supply_gregset etc. */
+#include "gregset.h"
/* This struct is defined by us, but mainly used for the proc_service interface.
We don't have much use for it, except as a handy place to get a real pid
static td_thragent_t *main_ta;
static int sol_thread_active = 0;
-static struct cleanup *save_inferior_pid PARAMS ((void));
-static void restore_inferior_pid PARAMS ((void *pid));
-static char *td_err_string PARAMS ((td_err_e errcode));
-static char *td_state_string PARAMS ((td_thr_state_e statecode));
-static int thread_to_lwp PARAMS ((int thread_id, int default_lwp));
-static void sol_thread_resume PARAMS ((int pid, int step,
- enum target_signal signo));
-static int lwp_to_thread PARAMS ((int lwp));
-static int sol_thread_alive PARAMS ((int pid));
-static void sol_core_close PARAMS ((int quitting));
+static struct cleanup *save_inferior_pid (void);
+static void restore_inferior_pid (void *pid);
+static char *td_err_string (td_err_e errcode);
+static char *td_state_string (td_thr_state_e statecode);
+static int thread_to_lwp (int thread_id, int default_lwp);
+static void sol_thread_resume (int pid, int step, enum target_signal signo);
+static int lwp_to_thread (int lwp);
+static int sol_thread_alive (int pid);
+static void sol_core_close (int quitting);
-static void init_sol_thread_ops PARAMS ((void));
-static void init_sol_core_ops PARAMS ((void));
+static void init_sol_thread_ops (void);
+static void init_sol_core_ops (void);
/* Default definitions: These must be defined in tm.h
if they are to be shared with a process module such as procfs. */
*/
static char *
-td_err_string (errcode)
- td_err_e errcode;
+td_err_string (td_err_e errcode)
{
static struct string_map
td_err_table[] =
*/
static char *
-td_state_string (statecode)
- td_thr_state_e statecode;
+td_state_string (td_thr_state_e statecode)
{
static struct string_map
td_thr_state_table[] =
*/
static int
-thread_to_lwp (thread_id, default_lwp)
- int thread_id;
- int default_lwp;
+thread_to_lwp (int thread_id, int default_lwp)
{
td_thrinfo_t ti;
td_thrhandle_t th;
*/
static int
-lwp_to_thread (lwp)
- int lwp;
+lwp_to_thread (int lwp)
{
td_thrinfo_t ti;
td_thrhandle_t th;
static struct cleanup *
-save_inferior_pid ()
+save_inferior_pid (void)
{
return make_cleanup (restore_inferior_pid, (void *) inferior_pid);
}
static void
-restore_inferior_pid (pid)
- void *pid;
+restore_inferior_pid (void *pid)
{
inferior_pid = (int) pid;
}
/* ARGSUSED */
static void
-sol_thread_open (arg, from_tty)
- char *arg;
- int from_tty;
+sol_thread_open (char *arg, int from_tty)
{
procfs_ops.to_open (arg, from_tty);
}
and wait for the trace-trap that results from attaching. */
static void
-sol_thread_attach (args, from_tty)
- char *args;
- int from_tty;
+sol_thread_attach (char *args, int from_tty)
{
procfs_ops.to_attach (args, from_tty);
+
/* Must get symbols from solibs before libthread_db can run! */
SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0);
+
if (sol_thread_active)
{
printf_filtered ("sol-thread active.\n");
started via the normal ptrace (PTRACE_TRACEME). */
static void
-sol_thread_detach (args, from_tty)
- char *args;
- int from_tty;
+sol_thread_detach (char *args, int from_tty)
{
inferior_pid = PIDGET (main_ph.pid);
unpush_target (&sol_thread_ops);
for procfs. */
static void
-sol_thread_resume (pid, step, signo)
- int pid;
- int step;
- enum target_signal signo;
+sol_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
-sol_thread_wait (pid, ourstatus)
- int pid;
- struct target_waitstatus *ourstatus;
+sol_thread_wait (int pid, struct target_waitstatus *ourstatus)
{
int rtnval;
int save_pid;
}
static void
-sol_thread_fetch_registers (regno)
- int regno;
+sol_thread_fetch_registers (int regno)
{
thread_t thread;
td_thrhandle_t thandle;
because the td routines call ps_lget* which affect the values stored in the
registers array. */
- supply_gregset (gregset);
- supply_fpregset (&fpregset);
+ supply_gregset ((gdb_gregset_t *) &gregset);
+ supply_fpregset ((gdb_fpregset_t *) &fpregset);
#if 0
/* thread_db doesn't seem to handle this right */
}
static void
-sol_thread_store_registers (regno)
- int regno;
+sol_thread_store_registers (int regno)
{
thread_t thread;
td_thrhandle_t thandle;
td_err_e val;
- prgregset_t regset;
+ prgregset_t gregset;
prfpregset_t fpregset;
#if 0
int xregsize;
char old_value[REGISTER_SIZE];
memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
- val = p_td_thr_getgregs (&thandle, regset);
+ val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_getgregs %s",
td_err_string (val));
#endif
}
- fill_gregset (regset, regno);
- fill_fpregset (&fpregset, regno);
+ fill_gregset ((gdb_gregset_t *) &gregset, regno);
+ fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);
- val = p_td_thr_setgregs (&thandle, regset);
+ val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_setgregs %s",
td_err_string (val));
debugged. */
static void
-sol_thread_prepare_to_store ()
+sol_thread_prepare_to_store (void)
{
procfs_ops.to_prepare_to_store ();
}
/* Print status information about what we're accessing. */
static void
-sol_thread_files_info (ignore)
- struct target_ops *ignore;
+sol_thread_files_info (struct target_ops *ignore)
{
procfs_ops.to_files_info (ignore);
}
static void
-sol_thread_kill_inferior ()
+sol_thread_kill_inferior (void)
{
procfs_ops.to_kill ();
}
static void
-sol_thread_notice_signals (pid)
- int pid;
+sol_thread_notice_signals (int pid)
{
procfs_ops.to_notice_signals (PIDGET (pid));
}
/* Fork an inferior process, and start debugging it with /proc. */
static void
-sol_thread_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
+sol_thread_create_inferior (char *exec_file, char *allargs, char **env)
{
procfs_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
-sol_thread_new_objfile (objfile)
- struct objfile *objfile;
+sol_thread_new_objfile (struct objfile *objfile)
{
td_err_e val;
/* Clean up after the inferior dies. */
static void
-sol_thread_mourn_inferior ()
+sol_thread_mourn_inferior (void)
{
unpush_target (&sol_thread_ops);
procfs_ops.to_mourn_inferior ();
/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
static int
-sol_thread_can_run ()
+sol_thread_can_run (void)
{
return procfs_suppress_run;
}
*/
static int
-sol_thread_alive (pid)
- int pid;
+sol_thread_alive (int pid)
{
if (is_thread (pid)) /* non-kernel thread */
{
}
static void
-sol_thread_stop ()
+sol_thread_stop (void)
{
procfs_ops.to_stop ();
}
inferior_pid = procfs_first_available (); /* Find any live lwp. */
/* Note: don't need to call switch_to_thread; we're just reading memory. */
+#if defined (__sparcv9)
+ /* For Sparc64 cross Sparc32, make sure the address has not been
+ accidentally sign-extended (or whatever) to beyond 32 bits. */
+ if (bfd_get_arch_size (exec_bfd) == 32)
+ addr &= 0xffffffff;
+#endif
+
while (size > 0)
{
int cc;
return PS_ERR;
}
+ else if (cc == 0)
+ {
+ if (dowrite == 0)
+ warning ("rw_common (): unable to read at addr 0x%lx",
+ (long) addr);
+ else
+ warning ("rw_common (): unable to write at addr 0x%lx",
+ (long) addr);
+
+ do_cleanups (old_chain);
+
+ return PS_ERR;
+ }
+
size -= cc;
buf += cc;
}
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_gregset (gregset, -1);
+ fill_gregset ((gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
- supply_gregset (gregset);
+ supply_gregset ((gdb_gregset_t *) gregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_fpregset (fpregset, -1);
+ fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
- supply_fpregset (fpregset);
+ supply_fpregset ((gdb_fpregset_t *) fpregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
return PS_OK;
}
+#ifdef PR_MODEL_LP64
+/* Identify process as 32-bit or 64-bit.
+ At the moment I'm using bfd to do this.
+ There might be a more solaris-specific (eg. procfs) method,
+ but this ought to work. */
+
+ps_err_e
+ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
+{
+ if (exec_bfd == 0)
+ return PS_ERR;
+
+ if (bfd_get_arch_size (exec_bfd) == 32)
+ *data_model = PR_MODEL_ILP32;
+ else
+ *data_model = PR_MODEL_LP64;
+
+ return PS_OK;
+}
+#endif /* PR_MODEL_LP64 */
+
#ifdef TM_I386SOL2_H
/* Reads the local descriptor table of a LWP. */
/* Convert a pid to printable form. */
char *
-solaris_pid_to_str (pid)
- int pid;
+solaris_pid_to_str (int pid)
{
static char buf[100];
kernel) thread. */
static int
-sol_find_new_threads_callback (th, ignored)
- const td_thrhandle_t *th;
- void *ignored;
+sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
{
td_err_e retval;
td_thrinfo_t ti;
}
static void
-sol_find_new_threads ()
+sol_find_new_threads (void)
{
/* don't do anything if init failed to resolve the libthread_db library */
if (!procfs_suppress_run)
}
static void
-sol_core_open (filename, from_tty)
- char *filename;
- int from_tty;
+sol_core_open (char *filename, int from_tty)
{
orig_core_ops.to_open (filename, from_tty);
}
static void
-sol_core_close (quitting)
- int quitting;
+sol_core_close (int quitting)
{
orig_core_ops.to_close (quitting);
}
static void
-sol_core_detach (args, from_tty)
- char *args;
- int from_tty;
+sol_core_detach (char *args, int from_tty)
{
unpush_target (&core_ops);
orig_core_ops.to_detach (args, from_tty);
}
static void
-sol_core_files_info (t)
- struct target_ops *t;
+sol_core_files_info (struct target_ops *t)
{
orig_core_ops.to_files_info (t);
}
inferior. Print anything interesting that we can think of. */
static int
-info_cb (th, s)
- const td_thrhandle_t *th;
- void *s;
+info_cb (const td_thrhandle_t *th, void *s)
{
td_err_e ret;
td_thrinfo_t ti;
/* List some state about each Solaris user thread in the inferior. */
static void
-info_solthreads (args, from_tty)
- char *args;
- int from_tty;
+info_solthreads (char *args, int from_tty)
{
p_td_ta_thr_iter (main_ta, info_cb, args,
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
}
static int
-ignore (addr, contents)
- CORE_ADDR addr;
- char *contents;
+ignore (CORE_ADDR addr, char *contents)
{
return 0;
}
static void
-init_sol_thread_ops ()
+init_sol_thread_ops (void)
{
sol_thread_ops.to_shortname = "solaris-threads";
sol_thread_ops.to_longname = "Solaris threads and pthread.";
static void
-init_sol_core_ops ()
+init_sol_core_ops (void)
{
sol_core_ops.to_shortname = "solaris-core";
sol_core_ops.to_longname = "Solaris core threads and pthread.";
int coreops_suppress_target = 1;
void
-_initialize_sol_thread ()
+_initialize_sol_thread (void)
{
void *dlhandle;
projects / deliverable / binutils-gdb.git / blobdiff