X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsol-thread.c;h=13b9580109260865298f725aaa4d4eb6c159de46;hb=4c2acfeafe154bef75318a35c1112433d8717cb5;hp=77e3fb14e9b44a280eba1d677ba83884dc60a879;hpb=e245aa6b0556c5e118bdbda01a3d2aa5a8c25b19;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c index 77e3fb14e9..13b9580109 100644 --- a/gdb/sol-thread.c +++ b/gdb/sol-thread.c @@ -1,5 +1,6 @@ /* Low level interface for debugging Solaris threads for GDB, the GNU debugger. - Copyright 1996, 1997, 1998 Free Software Foundation, Inc. + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. This file is part of GDB. @@ -57,6 +58,9 @@ #include #include #include "gdbcmd.h" +#include "gdbcore.h" +#include "regcache.h" +#include "symfile.h" extern struct target_ops sol_thread_ops; /* Forward declaration */ extern struct target_ops sol_core_ops; /* Forward declaration */ @@ -70,21 +74,10 @@ struct target_ops sol_core_ops; 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 (ptid_t ptid); + +/* 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 @@ -92,7 +85,7 @@ extern void fill_fpregset PARAMS ((prfpregset_t *, int)); struct ps_prochandle { - pid_t pid; + ptid_t ptid; }; struct string_map @@ -105,31 +98,29 @@ static struct ps_prochandle main_ph; 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 char *td_err_string (td_err_e errcode); +static char *td_state_string (td_thr_state_e statecode); +static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp); +static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo); +static ptid_t lwp_to_thread (ptid_t lwp); +static int sol_thread_alive (ptid_t ptid); +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. */ -#define THREAD_FLAG 0x80000000 -#define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0) -#define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0) -#define GET_LWP(PID) TIDGET (PID) -#define GET_THREAD(PID) TIDGET (PID) -#define BUILD_LWP(TID, PID) MERGEPID (PID, TID) +#define GET_PID(ptid) ptid_get_pid (ptid) +#define GET_LWP(ptid) ptid_get_lwp (ptid) +#define GET_THREAD(ptid) ptid_get_tid (ptid) + +#define is_lwp(ptid) (GET_LWP (ptid) != 0) +#define is_thread(ptid) (GET_THREAD (ptid) != 0) -#define BUILD_THREAD(TID, PID) (MERGEPID (PID, TID) | THREAD_FLAG) +#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) +#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid) /* Pointers to routines from lithread_db resolved by dlopen() */ @@ -204,8 +195,7 @@ static td_err_e (*p_td_thr_setgregs) (const td_thrhandle_t * th_p, */ static char * -td_err_string (errcode) - td_err_e errcode; +td_err_string (td_err_e errcode) { static struct string_map td_err_table[] = @@ -229,7 +219,7 @@ td_err_string (errcode) {TD_NOAPLIC, "Operation not applicable to"}, {TD_NOTSD, "No thread specific data for this thread"}, {TD_MALLOC, "Malloc failed"}, - {TD_PARTIALREG, "Only part of register set was writen/read"}, + {TD_PARTIALREG, "Only part of register set was written/read"}, {TD_NOXREGS, "X register set not available for given thread"} }; const int td_err_size = sizeof td_err_table / sizeof (struct string_map); @@ -263,8 +253,7 @@ td_err_string (errcode) */ 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[] = @@ -299,7 +288,7 @@ td_state_string (statecode) SYNOPSIS - int thread_to_lwp (thread_id, default_lwp) + tpid_t thread_to_lwp (thread_id, default_lwp) DESCRIPTION @@ -313,10 +302,8 @@ td_state_string (statecode) */ -static int -thread_to_lwp (thread_id, default_lwp) - int thread_id; - int default_lwp; +static ptid_t +thread_to_lwp (ptid_t thread_id, int default_lwp) { td_thrinfo_t ti; td_thrhandle_t th; @@ -329,20 +316,20 @@ thread_to_lwp (thread_id, default_lwp) val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th); if (val == TD_NOTHR) - return -1; /* thread must have terminated */ + return pid_to_ptid (-1); /* thread must have terminated */ else if (val != TD_OK) error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val)); val = p_td_thr_get_info (&th, &ti); if (val == TD_NOTHR) - return -1; /* thread must have terminated */ + return pid_to_ptid (-1); /* thread must have terminated */ else if (val != TD_OK) error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val)); if (ti.ti_state != TD_THR_ACTIVE) { if (default_lwp != -1) - return default_lwp; + return pid_to_ptid (default_lwp); error ("thread_to_lwp: thread state not active: %s", td_state_string (ti.ti_state)); } @@ -371,9 +358,8 @@ thread_to_lwp (thread_id, default_lwp) */ -static int -lwp_to_thread (lwp) - int lwp; +static ptid_t +lwp_to_thread (ptid_t lwp) { td_thrinfo_t ti; td_thrhandle_t th; @@ -385,11 +371,11 @@ lwp_to_thread (lwp) /* It's an lwp. Convert it to a thread id. */ if (!sol_thread_alive (lwp)) - return -1; /* defunct lwp */ + return pid_to_ptid (-1); /* defunct lwp */ val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th); if (val == TD_NOTHR) - return -1; /* thread must have terminated */ + return pid_to_ptid (-1); /* thread must have terminated */ else if (val != TD_OK) error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val)); @@ -402,54 +388,13 @@ lwp_to_thread (lwp) val = p_td_thr_get_info (&th, &ti); if (val == TD_NOTHR) - return -1; /* thread must have terminated */ + return pid_to_ptid (-1); /* thread must have terminated */ else if (val != TD_OK) error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val)); return BUILD_THREAD (ti.ti_tid, PIDGET (lwp)); } -/* - - LOCAL FUNCTION - - save_inferior_pid - Save inferior_pid on the cleanup list - restore_inferior_pid - Restore inferior_pid from the cleanup list - - SYNOPSIS - - struct cleanup *save_inferior_pid () - void restore_inferior_pid (int pid) - - DESCRIPTION - - These two functions act in unison to restore inferior_pid in - case of an error. - - NOTES - - inferior_pid is a global variable that needs to be changed by many of - these routines before calling functions in procfs.c. In order to - guarantee that inferior_pid gets restored (in case of errors), you - need to call save_inferior_pid before changing it. At the end of the - function, you should invoke do_cleanups to restore it. - - */ - - -static struct cleanup * -save_inferior_pid () -{ - return make_cleanup (restore_inferior_pid, (void *) inferior_pid); -} - -static void -restore_inferior_pid (pid) - void *pid; -{ - inferior_pid = (int) pid; -} - /* Most target vector functions from here on actually just pass through to procfs.c, as they don't need to do anything specific for threads. */ @@ -457,9 +402,7 @@ restore_inferior_pid (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); } @@ -468,23 +411,23 @@ sol_thread_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); + SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add); + if (sol_thread_active) { printf_filtered ("sol-thread active.\n"); - main_ph.pid = inferior_pid; /* Save for xfer_memory */ + main_ph.ptid = inferior_ptid; /* Save for xfer_memory */ push_target (&sol_thread_ops); - inferior_pid = lwp_to_thread (inferior_pid); - if (inferior_pid == -1) - inferior_pid = main_ph.pid; + inferior_ptid = lwp_to_thread (inferior_ptid); + if (PIDGET (inferior_ptid) == -1) + inferior_ptid = main_ph.ptid; else - add_thread (inferior_pid); + add_thread (inferior_ptid); } /* XXX - might want to iterate over all the threads and register them. */ } @@ -498,11 +441,9 @@ sol_thread_attach (args, from_tty) 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); + inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid)); unpush_target (&sol_thread_ops); procfs_ops.to_detach (args, from_tty); } @@ -513,32 +454,29 @@ sol_thread_detach (args, from_tty) for procfs. */ static void -sol_thread_resume (pid, step, signo) - int pid; - int step; - enum target_signal signo; +sol_thread_resume (ptid_t ptid, int step, enum target_signal signo) { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid); - if (inferior_pid == -1) - inferior_pid = procfs_first_available (); + inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid)); + if (PIDGET (inferior_ptid) == -1) + inferior_ptid = procfs_first_available (); - if (pid != -1) + if (PIDGET (ptid) != -1) { - int save_pid = pid; + ptid_t save_ptid = ptid; - pid = thread_to_lwp (pid, -2); - if (pid == -2) /* Inactive thread */ + ptid = thread_to_lwp (ptid, -2); + if (PIDGET (ptid) == -2) /* Inactive thread */ error ("This version of Solaris can't start inactive threads."); - if (info_verbose && pid == -1) - warning ("Specified thread %d seems to have terminated", - GET_THREAD (save_pid)); + if (info_verbose && PIDGET (ptid) == -1) + warning ("Specified thread %ld seems to have terminated", + GET_THREAD (save_ptid)); } - procfs_ops.to_resume (pid, step, signo); + procfs_ops.to_resume (ptid, step, signo); do_cleanups (old_chain); } @@ -546,46 +484,44 @@ sol_thread_resume (pid, step, signo) /* Wait for any threads to stop. We may have to convert PID from a thread id to a LWP id, and vice versa on the way out. */ -static int -sol_thread_wait (pid, ourstatus) - int pid; - struct target_waitstatus *ourstatus; +static ptid_t +sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus) { - int rtnval; - int save_pid; + ptid_t rtnval; + ptid_t save_ptid; struct cleanup *old_chain; - save_pid = inferior_pid; - old_chain = save_inferior_pid (); + save_ptid = inferior_ptid; + old_chain = save_inferior_ptid (); - inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid); - if (inferior_pid == -1) - inferior_pid = procfs_first_available (); + inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid)); + if (PIDGET (inferior_ptid) == -1) + inferior_ptid = procfs_first_available (); - if (pid != -1) + if (PIDGET (ptid) != -1) { - int save_pid = pid; + ptid_t save_ptid = ptid; - pid = thread_to_lwp (pid, -2); - if (pid == -2) /* Inactive thread */ + ptid = thread_to_lwp (ptid, -2); + if (PIDGET (ptid) == -2) /* Inactive thread */ error ("This version of Solaris can't start inactive threads."); - if (info_verbose && pid == -1) - warning ("Specified thread %d seems to have terminated", - GET_THREAD (save_pid)); + if (info_verbose && PIDGET (ptid) == -1) + warning ("Specified thread %ld seems to have terminated", + GET_THREAD (save_ptid)); } - rtnval = procfs_ops.to_wait (pid, ourstatus); + rtnval = procfs_ops.to_wait (ptid, ourstatus); if (ourstatus->kind != TARGET_WAITKIND_EXITED) { /* Map the LWP of interest back to the appropriate thread ID */ rtnval = lwp_to_thread (rtnval); - if (rtnval == -1) - rtnval = save_pid; + if (PIDGET (rtnval) == -1) + rtnval = save_ptid; /* See if we have a new thread */ if (is_thread (rtnval) - && rtnval != save_pid + && !ptid_equal (rtnval, save_ptid) && !in_thread_list (rtnval)) { printf_filtered ("[New %s]\n", target_pid_to_str (rtnval)); @@ -603,8 +539,7 @@ sol_thread_wait (pid, ourstatus) } static void -sol_thread_fetch_registers (regno) - int regno; +sol_thread_fetch_registers (int regno) { thread_t thread; td_thrhandle_t thandle; @@ -616,7 +551,7 @@ sol_thread_fetch_registers (regno) caddr_t xregset; #endif - if (!is_thread (inferior_pid)) + if (!is_thread (inferior_ptid)) { /* LWP: pass the request on to procfs.c */ if (target_has_execution) procfs_ops.to_fetch_registers (regno); @@ -625,9 +560,9 @@ sol_thread_fetch_registers (regno) return; } - /* Solaris thread: convert inferior_pid into a td_thrhandle_t */ + /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */ - thread = GET_THREAD (inferior_pid); + thread = GET_THREAD (inferior_ptid); if (thread == 0) error ("sol_thread_fetch_registers: thread == 0"); @@ -660,8 +595,8 @@ sol_thread_fetch_registers (regno) 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 */ @@ -682,28 +617,27 @@ sol_thread_fetch_registers (regno) } 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; caddr_t xregset; #endif - if (!is_thread (inferior_pid)) + if (!is_thread (inferior_ptid)) { /* LWP: pass the request on to procfs.c */ procfs_ops.to_store_registers (regno); return; } - /* Solaris thread: convert inferior_pid into a td_thrhandle_t */ + /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */ - thread = GET_THREAD (inferior_pid); + thread = GET_THREAD (inferior_ptid); val = p_td_ta_map_id2thr (main_ta, thread, &thandle); if (val != TD_OK) @@ -713,10 +647,11 @@ sol_thread_store_registers (regno) if (regno != -1) { /* Not writing all the regs */ /* save new register value */ - char old_value[REGISTER_SIZE]; - memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE); + char* old_value = (char*) alloca (REGISTER_SIZE); + memcpy (old_value, &deprecated_registers[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)); @@ -726,7 +661,8 @@ sol_thread_store_registers (regno) td_err_string (val)); /* restore new register value */ - memcpy (®isters[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE); + memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value, + REGISTER_SIZE); #if 0 /* thread_db doesn't seem to handle this right */ @@ -746,10 +682,10 @@ sol_thread_store_registers (regno) #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)); @@ -777,34 +713,38 @@ sol_thread_store_registers (regno) debugged. */ static void -sol_thread_prepare_to_store () +sol_thread_prepare_to_store (void) { procfs_ops.to_prepare_to_store (); } +/* Transfer LEN bytes between GDB address MYADDR and target address + MEMADDR. If DOWRITE is non-zero, transfer them to the target, + otherwise transfer them from the target. TARGET is unused. + + Returns the number of bytes transferred. */ + static int -sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int dowrite; - struct target_ops *target; /* ignored */ +sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite, + struct mem_attrib *attrib, + struct target_ops *target) { int retval; struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - if (is_thread (inferior_pid) || /* A thread */ - !target_thread_alive (inferior_pid)) /* An lwp, but not alive */ - inferior_pid = procfs_first_available (); /* Find any live lwp. */ + if (is_thread (inferior_ptid) || /* A thread */ + !target_thread_alive (inferior_ptid)) /* An lwp, but not alive */ + inferior_ptid = procfs_first_available (); /* Find any live lwp. */ /* Note: don't need to call switch_to_thread; we're just reading memory. */ if (target_has_execution) - retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target); + retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, + dowrite, attrib, target); else retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len, - dowrite, target); + dowrite, attrib, target); do_cleanups (old_chain); @@ -814,47 +754,42 @@ sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target) /* 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 (ptid_t ptid) { - procfs_ops.to_notice_signals (PIDGET (pid)); + procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid))); } /* 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); - if (sol_thread_active && inferior_pid != 0) + if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid)) { - main_ph.pid = inferior_pid; /* Save for xfer_memory */ + main_ph.ptid = inferior_ptid; /* Save for xfer_memory */ push_target (&sol_thread_ops); - inferior_pid = lwp_to_thread (inferior_pid); - if (inferior_pid == -1) - inferior_pid = main_ph.pid; + inferior_ptid = lwp_to_thread (inferior_ptid); + if (PIDGET (inferior_ptid) == -1) + inferior_ptid = main_ph.ptid; - if (!in_thread_list (inferior_pid)) - add_thread (inferior_pid); + if (!in_thread_list (inferior_ptid)) + add_thread (inferior_ptid); } } @@ -869,11 +804,10 @@ sol_thread_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; @@ -917,7 +851,7 @@ quit: /* 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 (); @@ -926,7 +860,7 @@ sol_thread_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; } @@ -939,7 +873,7 @@ sol_thread_can_run () SYNOPSIS - static bool sol_thread_alive (int pid); + static bool sol_thread_alive (ptid_t ptid); DESCRIPTION @@ -948,15 +882,15 @@ sol_thread_can_run () */ static int -sol_thread_alive (pid) - int pid; +sol_thread_alive (ptid_t ptid) { - if (is_thread (pid)) /* non-kernel thread */ + if (is_thread (ptid)) /* non-kernel thread */ { td_err_e val; td_thrhandle_t th; + int pid; - pid = GET_THREAD (pid); + pid = GET_THREAD (ptid); if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK) return 0; /* thread not found */ if ((val = p_td_thr_validate (&th)) != TD_OK) @@ -967,14 +901,14 @@ sol_thread_alive (pid) /* kernel thread (LWP): let procfs test it */ { if (target_has_execution) - return procfs_ops.to_thread_alive (pid); + return procfs_ops.to_thread_alive (ptid); else - return orig_core_ops.to_thread_alive (pid); + return orig_core_ops.to_thread_alive (ptid); } } static void -sol_thread_stop () +sol_thread_stop (void) { procfs_ops.to_stop (); } @@ -1075,21 +1009,31 @@ rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr, { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - if (is_thread (inferior_pid) || /* A thread */ - !target_thread_alive (inferior_pid)) /* An lwp, but not alive */ - inferior_pid = procfs_first_available (); /* Find any live lwp. */ + if (is_thread (inferior_ptid) || /* A thread */ + !target_thread_alive (inferior_ptid)) /* An lwp, but not alive */ + inferior_ptid = 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; + /* FIXME: passing 0 as attrib argument. */ if (target_has_execution) - cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops); + cc = procfs_ops.to_xfer_memory (addr, buf, size, + dowrite, 0, &procfs_ops); else - cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops); + cc = orig_core_ops.to_xfer_memory (addr, buf, size, + dowrite, 0, &core_ops); if (cc < 0) { @@ -1102,6 +1046,20 @@ rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr, 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; } @@ -1155,15 +1113,15 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid)); + inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); if (target_has_execution) 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); @@ -1178,11 +1136,11 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid)); + inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); - supply_gregset (gregset); + supply_gregset ((gdb_gregset_t *) gregset); if (target_has_execution) procfs_ops.to_store_registers (-1); else @@ -1287,15 +1245,15 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid)); + inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); if (target_has_execution) 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); @@ -1310,11 +1268,11 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, { struct cleanup *old_chain; - old_chain = save_inferior_pid (); + old_chain = save_inferior_ptid (); - inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid)); + inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); - supply_fpregset (fpregset); + supply_fpregset ((gdb_fpregset_t *) fpregset); if (target_has_execution) procfs_ops.to_store_registers (-1); else @@ -1325,6 +1283,26 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, 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) + *data_model = PR_MODEL_UNKNOWN; + else 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. */ @@ -1334,16 +1312,16 @@ ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid, struct ssd *pldt) { /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */ - extern struct ssd *procfs_find_LDT_entry (int); + extern struct ssd *procfs_find_LDT_entry (ptid_t); struct ssd *ret; /* FIXME: can't I get the process ID from the prochandle or something? */ - if (inferior_pid <= 0 || lwpid <= 0) + if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0) return PS_BADLID; - ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_pid))); + ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid))); if (ret) { memcpy (pldt, ret, sizeof (struct ssd)); @@ -1357,32 +1335,31 @@ ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid, /* Convert a pid to printable form. */ char * -solaris_pid_to_str (pid) - int pid; +solaris_pid_to_str (ptid_t ptid) { static char buf[100]; /* in case init failed to resolve the libthread_db library */ if (!procfs_suppress_run) - return procfs_pid_to_str (pid); + return procfs_pid_to_str (ptid); - if (is_thread (pid)) + if (is_thread (ptid)) { - int lwp; + ptid_t lwp; - lwp = thread_to_lwp (pid, -2); + lwp = thread_to_lwp (ptid, -2); - if (lwp == -1) - sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid)); - else if (lwp != -2) - sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp)); + if (PIDGET (lwp) == -1) + sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid)); + else if (PIDGET (lwp) != -2) + sprintf (buf, "Thread %ld (LWP %ld)", GET_THREAD (ptid), GET_LWP (lwp)); else - sprintf (buf, "Thread %d ", GET_THREAD (pid)); + sprintf (buf, "Thread %ld ", GET_THREAD (ptid)); } - else if (GET_LWP (pid) != 0) - sprintf (buf, "LWP %d ", GET_LWP (pid)); + else if (GET_LWP (ptid) != 0) + sprintf (buf, "LWP %ld ", GET_LWP (ptid)); else - sprintf (buf, "process %d ", PIDGET (pid)); + sprintf (buf, "process %d ", PIDGET (ptid)); return buf; } @@ -1393,70 +1370,62 @@ solaris_pid_to_str (pid) 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; - int pid; + ptid_t ptid; if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK) { return -1; } - pid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_pid)); - if (!in_thread_list (pid)) - add_thread (pid); + ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid)); + if (!in_thread_list (ptid)) + add_thread (ptid); return 0; } 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) return; - if (inferior_pid == -1) + if (PIDGET (inferior_ptid) == -1) { printf_filtered ("No process.\n"); return; } - procfs_find_new_threads (); /* first find new kernel threads. */ + procfs_ops.to_find_new_threads (); /* first find new kernel threads */ p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0, TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS); } 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); } @@ -1466,9 +1435,7 @@ sol_core_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; @@ -1538,9 +1505,7 @@ info_cb (th, s) /* 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, @@ -1548,22 +1513,35 @@ info_solthreads (args, from_tty) } static int -ignore (addr, contents) - CORE_ADDR addr; - char *contents; +sol_find_memory_regions (int (*func) (CORE_ADDR, + unsigned long, + int, int, int, + void *), + void *data) +{ + return procfs_ops.to_find_memory_regions (func, data); +} + +static char * +sol_make_note_section (bfd *obfd, int *note_size) +{ + return procfs_ops.to_make_corefile_notes (obfd, note_size); +} + +static int +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."; sol_thread_ops.to_doc = "Solaris threads and pthread support."; sol_thread_ops.to_open = sol_thread_open; - sol_thread_ops.to_close = 0; sol_thread_ops.to_attach = sol_thread_attach; sol_thread_ops.to_detach = sol_thread_detach; sol_thread_ops.to_resume = sol_thread_resume; @@ -1579,10 +1557,9 @@ init_sol_thread_ops () sol_thread_ops.to_terminal_inferior = terminal_inferior; sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output; sol_thread_ops.to_terminal_ours = terminal_ours; + sol_thread_ops.to_terminal_save_ours = terminal_save_ours; sol_thread_ops.to_terminal_info = child_terminal_info; sol_thread_ops.to_kill = sol_thread_kill_inferior; - sol_thread_ops.to_load = 0; - sol_thread_ops.to_lookup_symbol = 0; sol_thread_ops.to_create_inferior = sol_thread_create_inferior; sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior; sol_thread_ops.to_can_run = sol_thread_can_run; @@ -1598,14 +1575,14 @@ init_sol_thread_ops () sol_thread_ops.to_has_registers = 1; sol_thread_ops.to_has_execution = 1; sol_thread_ops.to_has_thread_control = tc_none; - sol_thread_ops.to_sections = 0; - sol_thread_ops.to_sections_end = 0; + sol_thread_ops.to_find_memory_regions = sol_find_memory_regions; + sol_thread_ops.to_make_corefile_notes = sol_make_note_section; sol_thread_ops.to_magic = OPS_MAGIC; } 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."; @@ -1614,30 +1591,16 @@ init_sol_core_ops () sol_core_ops.to_close = sol_core_close; sol_core_ops.to_attach = sol_thread_attach; sol_core_ops.to_detach = sol_core_detach; - /* sol_core_ops.to_resume = 0; */ - /* sol_core_ops.to_wait = 0; */ sol_core_ops.to_fetch_registers = sol_thread_fetch_registers; - /* sol_core_ops.to_store_registers = 0; */ - /* sol_core_ops.to_prepare_to_store = 0; */ sol_core_ops.to_xfer_memory = sol_thread_xfer_memory; sol_core_ops.to_files_info = sol_core_files_info; sol_core_ops.to_insert_breakpoint = ignore; sol_core_ops.to_remove_breakpoint = ignore; - /* sol_core_ops.to_terminal_init = 0; */ - /* sol_core_ops.to_terminal_inferior = 0; */ - /* sol_core_ops.to_terminal_ours_for_output = 0; */ - /* sol_core_ops.to_terminal_ours = 0; */ - /* sol_core_ops.to_terminal_info = 0; */ - /* sol_core_ops.to_kill = 0; */ - /* sol_core_ops.to_load = 0; */ - /* sol_core_ops.to_lookup_symbol = 0; */ sol_core_ops.to_create_inferior = sol_thread_create_inferior; sol_core_ops.to_stratum = core_stratum; - sol_core_ops.to_has_all_memory = 0; sol_core_ops.to_has_memory = 1; sol_core_ops.to_has_stack = 1; sol_core_ops.to_has_registers = 1; - sol_core_ops.to_has_execution = 0; sol_core_ops.to_has_thread_control = tc_none; sol_core_ops.to_thread_alive = sol_thread_alive; sol_core_ops.to_pid_to_str = solaris_pid_to_str; @@ -1646,8 +1609,6 @@ init_sol_core_ops () in procinfo list" where is the pid of the process that produced the core file. Disable it for now. */ /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */ - sol_core_ops.to_sections = 0; - sol_core_ops.to_sections_end = 0; sol_core_ops.to_magic = OPS_MAGIC; } @@ -1658,7 +1619,7 @@ init_sol_core_ops () int coreops_suppress_target = 1; void -_initialize_sol_thread () +_initialize_sol_thread (void) { void *dlhandle;