/* Solaris threads debugging interface.
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2007, 2008 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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This module implements a sort of half target that sits between the
machine-independent parts of GDB and the /proc interface (procfs.c)
#include "regcache.h"
#include "solib.h"
#include "symfile.h"
+#include "observer.h"
#include "gdb_string.h"
if (is_thread (rtnval)
&& !ptid_equal (rtnval, save_ptid)
&& !in_thread_list (rtnval))
- {
- printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
- add_thread (rtnval);
- }
+ add_thread (rtnval);
}
/* During process initialization, we may get here without the thread
}
static void
-sol_thread_fetch_registers (int regnum)
+sol_thread_fetch_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
td_err_e val;
prgregset_t gregset;
prfpregset_t fpregset;
+ gdb_gregset_t *gregset_p = &gregset;
+ gdb_fpregset_t *fpregset_p = &fpregset;
+
#if 0
int xregsize;
caddr_t xregset;
{
/* It's an LWP; pass the request on to procfs. */
if (target_has_execution)
- procfs_ops.to_fetch_registers (regnum);
+ procfs_ops.to_fetch_registers (regcache, regnum);
else
- orig_core_ops.to_fetch_registers (regnum);
+ orig_core_ops.to_fetch_registers (regcache, regnum);
return;
}
calling the td routines because the td routines call ps_lget*
which affect the values stored in the registers array. */
- supply_gregset ((gdb_gregset_t *) &gregset);
- supply_fpregset ((gdb_fpregset_t *) &fpregset);
+ supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
+ supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
}
static void
-sol_thread_store_registers (int regnum)
+sol_thread_store_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
if (!is_thread (inferior_ptid))
{
/* It's an LWP; pass the request on to procfs.c. */
- procfs_ops.to_store_registers (regnum);
+ procfs_ops.to_store_registers (regcache, regnum);
return;
}
char old_value[MAX_REGISTER_SIZE];
/* Save new register value. */
- regcache_raw_collect (current_regcache, regnum, old_value);
+ regcache_raw_collect (regcache, regnum, old_value);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
td_err_string (val));
/* Restore new register value. */
- regcache_raw_supply (current_regcache, regnum, old_value);
+ regcache_raw_supply (regcache, regnum, old_value);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
#endif
}
- fill_gregset ((gdb_gregset_t *) &gregset, regnum);
- fill_fpregset ((gdb_fpregset_t *) &fpregset, regnum);
+ fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
+ fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
program being debugged. */
static void
-sol_thread_prepare_to_store (void)
+sol_thread_prepare_to_store (struct regcache *regcache)
{
- procfs_ops.to_prepare_to_store ();
+ procfs_ops.to_prepare_to_store (regcache);
}
/* Transfer LEN bytes between GDB address MYADDR and target address
when all symbol tables are removed. libthread_db can only be
initialized when it finds the right variables in libthread.so.
Since it's a shared library, those variables don't show up until
- the library gets mapped and the symbol table is read in.
-
- This new_objfile event is managed by a chained function pointer.
- It is the callee's responsability to call the next client on the
- chain. */
+ the library gets mapped and the symbol table is read in. */
-/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) (struct objfile *);
-
-void
+static void
sol_thread_new_objfile (struct objfile *objfile)
{
td_err_e val;
if (!objfile)
{
sol_thread_active = 0;
- goto quit;
+ return;
}
/* Don't do anything if init failed to resolve the libthread_db
library. */
if (!procfs_suppress_run)
- goto quit;
+ return;
/* Now, initialize libthread_db. This needs to be done after the
shared libraries are located because it needs information from
if (val != TD_OK)
{
warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (val));
- goto quit;
+ return;
}
val = p_td_ta_new (&main_ph, &main_ta);
if (val == TD_NOLIBTHREAD)
- goto quit;
+ return;
else if (val != TD_OK)
{
warning (_("sol_thread_new_objfile: td_ta_new: %s"), td_err_string (val));
- goto quit;
+ return;
}
sol_thread_active = 1;
-
-quit:
- /* Call predecessor on chain, if any. */
- if (target_new_objfile_chain)
- target_new_objfile_chain (objfile);
}
/* Clean up after the inferior dies. */
}
static void
-sol_thread_stop (void)
+sol_thread_stop (ptid_t ptid)
{
- procfs_ops.to_stop ();
+ procfs_ops.to_stop (ptid);
}
\f
/* These routines implement the lower half of the thread_db interface,
typedef char *gdb_ps_read_buf_t;
typedef char *gdb_ps_write_buf_t;
typedef int gdb_ps_size_t;
-typedef paddr_t gdb_ps_addr_t;
+typedef psaddr_t gdb_ps_addr_t;
#else
typedef struct ps_prochandle *gdb_ps_prochandle_t;
typedef void *gdb_ps_read_buf_t;
ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
{
struct cleanup *old_chain;
+ struct regcache *regcache;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+ regcache = get_thread_regcache (inferior_ptid);
if (target_has_execution)
- procfs_ops.to_fetch_registers (-1);
+ procfs_ops.to_fetch_registers (regcache, -1);
else
- orig_core_ops.to_fetch_registers (-1);
- fill_gregset ((gdb_gregset_t *) gregset, -1);
+ orig_core_ops.to_fetch_registers (regcache, -1);
+ fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
const prgregset_t gregset)
{
struct cleanup *old_chain;
+ struct regcache *regcache;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+ regcache = get_thread_regcache (inferior_ptid);
- supply_gregset ((gdb_gregset_t *) gregset);
+ supply_gregset (regcache, (const gdb_gregset_t *) gregset);
if (target_has_execution)
- procfs_ops.to_store_registers (-1);
+ procfs_ops.to_store_registers (regcache, -1);
else
- orig_core_ops.to_store_registers (-1);
+ orig_core_ops.to_store_registers (regcache, -1);
do_cleanups (old_chain);
prfpregset_t *fpregset)
{
struct cleanup *old_chain;
+ struct regcache *regcache;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+ regcache = get_thread_regcache (inferior_ptid);
if (target_has_execution)
- procfs_ops.to_fetch_registers (-1);
+ procfs_ops.to_fetch_registers (regcache, -1);
else
- orig_core_ops.to_fetch_registers (-1);
- fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
+ orig_core_ops.to_fetch_registers (regcache, -1);
+ fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
const prfpregset_t * fpregset)
{
struct cleanup *old_chain;
+ struct regcache *regcache;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
+ regcache = get_thread_regcache (inferior_ptid);
- supply_fpregset ((gdb_fpregset_t *) fpregset);
+ supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
if (target_has_execution)
- procfs_ops.to_store_registers (-1);
+ procfs_ops.to_store_registers (regcache, -1);
else
- orig_core_ops.to_store_registers (-1);
+ orig_core_ops.to_store_registers (regcache, -1);
do_cleanups (old_chain);
}
#endif /* PR_MODEL_LP64 */
-#ifdef TM_I386SOL2_H
+#if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
-/* Reads the local descriptor table of a LWP. */
+/* Reads the local descriptor table of a LWP.
+
+ This function is necessary on x86-solaris only. Without it, the loading
+ of libthread_db would fail because of ps_lgetLDT being undefined. */
ps_err_e
ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
/* LDT not found. */
return PS_ERR;
}
-#endif /* TM_I386SOL2_H */
+#endif
\f
/* Convert PTID to printable form. */
add_target (&core_ops);
/* Hook into new_objfile notification. */
- target_new_objfile_chain = deprecated_target_new_objfile_hook;
- deprecated_target_new_objfile_hook = sol_thread_new_objfile;
+ observer_attach_new_objfile (sol_thread_new_objfile);
return;
die:
projects / deliverable / binutils-gdb.git / blobdiff