/* Solaris threads debugging interface.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
- 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, 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 "gdbcmd.h"
#include "gdbcore.h"
#include "regcache.h"
+#include "solib.h"
#include "symfile.h"
+#include "observer.h"
#include "gdb_string.h"
/* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
doesn't exist, that's an error. If it's an inactive thread, return
- DEFAULT_LPW.
+ DEFAULT_LWP.
NOTE: This function probably shouldn't call error(). */
if (val == TD_NOTHR)
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));
+ 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 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));
+ 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 pid_to_ptid (default_lwp);
- error ("thread_to_lwp: thread state not active: %s",
+ error (_("thread_to_lwp: thread state not active: %s"),
td_state_string (ti.ti_state));
}
if (val == TD_NOTHR)
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));
+ error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
val = p_td_thr_validate (&th);
if (val == TD_NOTHR)
return lwp; /* Unknown to libthread; just return LPW, */
else if (val != TD_OK)
- error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
+ error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
val = p_td_thr_get_info (&th, &ti);
if (val == TD_NOTHR)
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));
+ error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
}
for the trace-trap that results from attaching. */
static void
-sol_thread_attach (char *args, int from_tty)
+sol_thread_attach (struct target_ops *ops, char *args, int from_tty)
{
- procfs_ops.to_attach (args, from_tty);
+ sol_thread_active = 0;
+ procfs_ops.to_attach (&procfs_ops, args, from_tty);
/* Must get symbols from shared libraries before libthread_db can run! */
- SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
+ solib_add (NULL, from_tty, (struct target_ops *) 0, auto_solib_add);
if (sol_thread_active)
{
+ ptid_t ptid;
printf_filtered ("sol-thread active.\n");
main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
push_target (&sol_thread_ops);
- inferior_ptid = lwp_to_thread (inferior_ptid);
- if (PIDGET (inferior_ptid) == -1)
- inferior_ptid = main_ph.ptid;
- else
- add_thread (inferior_ptid);
+ ptid = lwp_to_thread (inferior_ptid);
+ if (PIDGET (ptid) != -1)
+ thread_change_ptid (inferior_ptid, ptid);
}
/* FIXME: Might want to iterate over all the threads and register
program was started via the normal ptrace (PTRACE_TRACEME). */
static void
-sol_thread_detach (char *args, int from_tty)
+sol_thread_detach (struct target_ops *ops, char *args, int from_tty)
{
+ sol_thread_active = 0;
inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
unpush_target (&sol_thread_ops);
- procfs_ops.to_detach (args, from_tty);
+ procfs_ops.to_detach (&procfs_ops, args, from_tty);
}
/* Resume execution of process PTID. If STEP is nozero, then just
ptid = thread_to_lwp (ptid, -2);
if (PIDGET (ptid) == -2) /* Inactive thread. */
- error ("This version of Solaris can't start inactive threads.");
+ error (_("This version of Solaris can't start inactive threads."));
if (info_verbose && PIDGET (ptid) == -1)
- warning ("Specified thread %ld seems to have terminated",
+ warning (_("Specified thread %ld seems to have terminated"),
GET_THREAD (save_ptid));
}
do_cleanups (old_chain);
}
-/* Wait for any threads to stop. We may have to convert PIID from a
+/* Wait for any threads to stop. We may have to convert PTID from a
thread ID to an LWP ID, and vice versa on the way out. */
static ptid_t
ptid = thread_to_lwp (ptid, -2);
if (PIDGET (ptid) == -2) /* Inactive thread. */
- error ("This version of Solaris can't start inactive threads.");
+ error (_("This version of Solaris can't start inactive threads."));
if (info_verbose && PIDGET (ptid) == -1)
- warning ("Specified thread %ld seems to have terminated",
+ warning (_("Specified thread %ld seems to have terminated"),
GET_THREAD (save_ptid));
}
/* See if we have a new thread. */
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);
- }
+ && (!in_thread_list (rtnval)
+ || is_exited (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;
}
/* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
thread = GET_THREAD (inferior_ptid);
if (thread == 0)
- error ("sol_thread_fetch_registers: thread == 0");
+ error (_("sol_thread_fetch_registers: thread == 0"));
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
- error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
+ error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
td_err_string (val));
/* Get the general-purpose registers. */
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK && val != TD_PARTIALREG)
- error ("sol_thread_fetch_registers: td_thr_getgregs %s",
+ error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
td_err_string (val));
/* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
val = p_td_thr_getfpregs (&thandle, &fpregset);
if (val != TD_OK && val != TD_NOFPREGS)
- error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
+ error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
td_err_string (val));
/* Note that we must call supply_gregset and supply_fpregset *after*
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. */
val = td_thr_getxregsize (&thandle, &xregsize);
if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
+ error (_("sol_thread_fetch_registers: td_thr_getxregsize %s"),
td_err_string (val));
if (val == TD_OK)
xregset = alloca (xregsize);
val = td_thr_getxregs (&thandle, xregset);
if (val != TD_OK)
- error ("sol_thread_fetch_registers: td_thr_getxregs %s",
+ error (_("sol_thread_fetch_registers: td_thr_getxregs %s"),
td_err_string (val));
}
#endif
}
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;
}
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_ta_map_id2thr %s",
+ error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
td_err_string (val));
if (regnum != -1)
char old_value[MAX_REGISTER_SIZE];
/* Save new register value. */
- regcache_collect (regnum, old_value);
+ regcache_raw_collect (regcache, regnum, old_value);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getgregs %s",
+ error (_("sol_thread_store_registers: td_thr_getgregs %s"),
td_err_string (val));
val = p_td_thr_getfpregs (&thandle, &fpregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getfpregs %s",
+ error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
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. */
val = td_thr_getxregsize (&thandle, &xregsize);
if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_store_registers: td_thr_getxregsize %s",
+ error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
td_err_string (val));
if (val == TD_OK)
xregset = alloca (xregsize);
val = td_thr_getxregs (&thandle, xregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getxregs %s",
+ error (_("sol_thread_store_registers: td_thr_getxregs %s"),
td_err_string (val));
}
#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)
- error ("sol_thread_store_registers: td_thr_setgregs %s",
+ error (_("sol_thread_store_registers: td_thr_setgregs %s"),
td_err_string (val));
val = p_td_thr_setfpregs (&thandle, &fpregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_setfpregs %s",
+ error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
td_err_string (val));
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
val = td_thr_getxregsize (&thandle, &xregsize);
if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_store_registers: td_thr_getxregsize %s",
+ error (_("sol_thread_store_registers: td_thr_getxregsize %s"),
td_err_string (val));
/* ??? Should probably do something about writing the xregs here,
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
Returns the number of bytes transferred. */
static int
-sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
- struct mem_attrib *attrib,
+sol_thread_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+ int dowrite, struct mem_attrib *attrib,
struct target_ops *target)
{
int retval;
}
if (target_has_execution)
- retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len,
- dowrite, attrib, target);
+ retval = procfs_ops.deprecated_xfer_memory (memaddr, myaddr, len,
+ dowrite, attrib, target);
else
- retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
- dowrite, attrib, target);
+ retval = orig_core_ops.deprecated_xfer_memory (memaddr, myaddr, len,
+ dowrite, attrib, target);
do_cleanups (old_chain);
static LONGEST
sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, void *readbuf,
- const void *writebuf, ULONGEST offset, LONGEST len)
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len)
{
int retval;
struct cleanup *old_chain;
/* Fork an inferior process, and start debugging it with /proc. */
static void
-sol_thread_create_inferior (char *exec_file, char *allargs, char **env,
- int from_tty)
+sol_thread_create_inferior (struct target_ops *ops, char *exec_file,
+ char *allargs, char **env, int from_tty)
{
- procfs_ops.to_create_inferior (exec_file, allargs, env, from_tty);
+ sol_thread_active = 0;
+ procfs_ops.to_create_inferior (&procfs_ops, exec_file, allargs, env, from_tty);
if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
{
+ ptid_t ptid;
+
/* Save for xfer_memory. */
main_ph.ptid = inferior_ptid;
push_target (&sol_thread_ops);
- inferior_ptid = lwp_to_thread (inferior_ptid);
- if (PIDGET (inferior_ptid) == -1)
- inferior_ptid = main_ph.ptid;
-
- if (!in_thread_list (inferior_ptid))
- add_thread (inferior_ptid);
+ ptid = lwp_to_thread (inferior_ptid);
+ if (PIDGET (ptid) != -1)
+ thread_change_ptid (inferior_ptid, ptid);
}
}
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. */
-
-/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) (struct objfile *);
+ the library gets mapped and the symbol table is read in. */
-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
val = p_td_init ();
if (val != TD_OK)
{
- warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val));
- goto quit;
+ warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (val));
+ 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;
+ warning (_("sol_thread_new_objfile: td_ta_new: %s"), td_err_string (val));
+ 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_mourn_inferior (void)
+sol_thread_mourn_inferior (struct target_ops *ops)
{
+ sol_thread_active = 0;
unpush_target (&sol_thread_ops);
- procfs_ops.to_mourn_inferior ();
+ procfs_ops.to_mourn_inferior (&procfs_ops);
}
/* Mark our target-struct as eligible for stray "run" and "attach"
}
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;
/* FIXME: passing 0 as attrib argument. */
if (target_has_execution)
- cc = procfs_ops.to_xfer_memory (addr, buf, size,
- dowrite, 0, &procfs_ops);
+ cc = procfs_ops.deprecated_xfer_memory (addr, buf, size,
+ dowrite, 0, &procfs_ops);
else
- cc = orig_core_ops.to_xfer_memory (addr, buf, size,
- dowrite, 0, &core_ops);
+ cc = orig_core_ops.deprecated_xfer_memory (addr, buf, size,
+ dowrite, 0, &core_ops);
if (cc < 0)
{
else if (cc == 0)
{
if (dowrite == 0)
- warning ("rw_common (): unable to read at addr 0x%lx",
+ warning (_("rw_common (): unable to read at addr 0x%lx"),
(long) addr);
else
- warning ("rw_common (): unable to write at addr 0x%lx",
+ warning (_("rw_common (): unable to write at addr 0x%lx"),
(long) addr);
do_cleanups (old_chain);
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. */
return -1;
ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
- if (!in_thread_list (ptid))
+ if (!in_thread_list (ptid) || is_exited (ptid))
add_thread (ptid);
return 0;
}
static void
-sol_core_detach (char *args, int from_tty)
+sol_core_detach (struct target_ops *ops, char *args, int from_tty)
{
unpush_target (&core_ops);
- orig_core_ops.to_detach (args, from_tty);
+ orig_core_ops.to_detach (&orig_core_ops, args, from_tty);
}
static void
msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
if (msym)
printf_filtered (" startfunc: %s\n",
- DEPRECATED_SYMBOL_NAME (msym));
+ SYMBOL_PRINT_NAME (msym));
else
printf_filtered (" startfunc: 0x%s\n", paddr (ti.ti_startfunc));
}
msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
if (msym)
printf_filtered (" - Sleep func: %s\n",
- DEPRECATED_SYMBOL_NAME (msym));
+ SYMBOL_PRINT_NAME (msym));
else
printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
}
printf_filtered ("\n"); /* don't you hate counting newlines? */
}
else
- warning ("info sol-thread: failed to get info for thread.");
+ warning (_("info sol-thread: failed to get info for thread."));
return 0;
}
}
static int
-ignore (CORE_ADDR addr, char *contents)
+ignore (struct bp_target_info *bp_tgt)
{
return 0;
}
sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
sol_thread_ops.to_store_registers = sol_thread_store_registers;
sol_thread_ops.to_prepare_to_store = sol_thread_prepare_to_store;
- sol_thread_ops.to_xfer_memory = sol_thread_xfer_memory;
+ sol_thread_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
sol_thread_ops.to_files_info = sol_thread_files_info;
sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
sol_core_ops.to_attach = sol_thread_attach;
sol_core_ops.to_detach = sol_core_detach;
sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
- sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
+ sol_core_ops.deprecated_xfer_memory = sol_thread_xfer_memory;
sol_core_ops.to_xfer_partial = sol_thread_xfer_partial;
sol_core_ops.to_files_info = sol_core_files_info;
sol_core_ops.to_insert_breakpoint = ignore;
procfs_suppress_run = 1;
add_cmd ("sol-threads", class_maintenance, info_solthreads,
- "Show info on Solaris user threads.\n", &maintenanceinfolist);
+ _("Show info on Solaris user threads."), &maintenanceinfolist);
+ /* FIXME: This code takes errant advantage of the order in which
+ initialization routines are run. _initialize_corelow must run before
+ this one otherwise orig_core_ops will still contain zeros and the work
+ of init_sol_core_ops will be undone. */
memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
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: