/* Low level interface for debugging AIX 4.3+ pthreads.
- Copyright (C) 1999, 2000, 2002, 2007 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2002, 2007, 2008, 2009
+ Free Software Foundation, Inc.
Written by Nick Duffek <nsd@redhat.com>.
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 uses the libpthdebug.a library provided by AIX 4.3+ for
#include "gdbcmd.h"
#include "ppc-tdep.h"
#include "gdb_string.h"
+#include "observer.h"
#include <procinfo.h>
#include <sys/types.h>
static int arch64;
-/* Saved pointer to previous owner of
- deprecated_target_new_objfile_hook. */
-
-static void (*target_new_objfile_chain)(struct objfile *);
-
/* Forward declarations for pthdb callbacks. */
static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int);
/* Floating-point registers. */
if (flags & PTHDB_FLAG_FPRS)
{
- if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
+ if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL))
memset (fprs, 0, sizeof (fprs));
- memcpy (context->fpr, fprs, sizeof(fprs));
+ memcpy (context->fpr, fprs, sizeof(fprs));
}
/* Special-purpose registers. */
}
else
{
- ptrace32 (PTT_WRITE_SPRS, tid, (int *) &context->msr, 0, NULL);
+ ptrace32 (PTT_WRITE_SPRS, tid, (void *) &context->msr, 0, NULL);
}
}
return 0;
unpush_target (&aix_thread_ops);
}
-/* deprecated_target_new_objfile_hook callback.
+/* new_objfile observer callback.
If OBJFILE is non-null, check whether a threaded application is
being debugged, and if so, prepare for thread debugging.
pd_enable ();
else
pd_disable ();
-
- if (target_new_objfile_chain)
- target_new_objfile_chain (objfile);
}
/* Attach to process specified by ARGS. */
static void
-aix_thread_attach (char *args, int from_tty)
+aix_thread_attach (struct target_ops *ops, char *args, int from_tty)
{
- base_target.to_attach (args, from_tty);
+ base_target.to_attach (&base_target, args, from_tty);
pd_activate (1);
}
/* Detach from the process attached to by aix_thread_attach(). */
static void
-aix_thread_detach (char *args, int from_tty)
+aix_thread_detach (struct target_ops *ops, char *args, int from_tty)
{
pd_disable ();
- base_target.to_detach (args, from_tty);
+ base_target.to_detach (&base_target, args, from_tty);
}
/* Tell the inferior process to continue running thread PID if != -1
if (arch64)
ptrace64aix (PTT_CONTINUE, tid[0], 1,
- target_signal_to_host (sig), (int *) tid);
+ target_signal_to_host (sig), (void *) tid);
else
ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
- target_signal_to_host (sig), (int *) tid);
+ target_signal_to_host (sig), (void *) tid);
}
}
thread. */
static ptid_t
-aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
struct cleanup *cleanup = save_inferior_ptid ();
pid_to_prc (&ptid);
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- ptid = base_target.to_wait (ptid, status);
+ ptid = base_target.to_wait (&base_target, ptid, status);
do_cleanups (cleanup);
if (PIDGET (ptid) == -1)
return pid_to_ptid (-1);
/* Check whether libpthdebug might be ready to be initialized. */
- if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED &&
- status->value.sig == TARGET_SIGNAL_TRAP &&
- read_pc_pid (ptid) - DECR_PC_AFTER_BREAK == pd_brk_addr)
- return pd_activate (0);
+ if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
+ && status->value.sig == TARGET_SIGNAL_TRAP)
+ {
+ struct regcache *regcache = get_thread_regcache (ptid);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
+ if (regcache_read_pc (regcache)
+ - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
+ return pd_activate (0);
+ }
return pd_update (0);
}
static void
supply_gprs64 (struct regcache *regcache, uint64_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
static void
supply_fprs (struct regcache *regcache, double *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
int regno;
/* This function should never be called on architectures without
floating-point registers. */
- gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
+ gdb_assert (ppc_floating_point_unit_p (gdbarch));
for (regno = 0; regno < ppc_num_fprs; regno++)
regcache_raw_supply (regcache, regno + tdep->ppc_fp0_regnum,
/* Predicate to test whether given register number is a "special" register. */
static int
-special_register_p (int regno)
+special_register_p (struct gdbarch *gdbarch, int regno)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- return regno == PC_REGNUM
+ return regno == gdbarch_pc_regnum (gdbarch)
|| regno == tdep->ppc_ps_regnum
|| regno == tdep->ppc_cr_regnum
|| regno == tdep->ppc_lr_regnum
uint64_t lr, uint64_t ctr, uint32_t xer,
uint32_t fpscr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar);
+ regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
+ (char *) &iar);
regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
uint32_t lr, uint32_t ctr, uint32_t xer,
uint32_t fpscr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar);
+ regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
+ (char *) &iar);
regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
static void
fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
int status, i;
pthdb_context_t ctx;
/* Floating-point registers. */
- if (ppc_floating_point_unit_p (current_gdbarch))
+ if (ppc_floating_point_unit_p (gdbarch))
supply_fprs (regcache, ctx.fpr);
/* Special registers. */
fetch_regs_kernel_thread (struct regcache *regcache, int regno,
pthdb_tid_t tid)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
uint64_t gprs64[ppc_num_gprs];
uint32_t gprs32[ppc_num_gprs];
double fprs[ppc_num_fprs];
/* Floating-point registers. */
- if (ppc_floating_point_unit_p (current_gdbarch)
+ if (ppc_floating_point_unit_p (gdbarch)
&& (regno == -1
|| (regno >= tdep->ppc_fp0_regnum
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{
- if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
+ if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL))
memset (fprs, 0, sizeof (fprs));
supply_fprs (regcache, fprs);
}
/* Special-purpose registers. */
- if (regno == -1 || special_register_p (regno))
+ if (regno == -1 || special_register_p (gdbarch, regno))
{
if (arch64)
{
}
else
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
memset (&sprs32, 0, sizeof (sprs32));
static void
fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
static void
fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
static void
fill_fprs (const struct regcache *regcache, double *vals)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
int regno;
/* This function should never be called on architectures without
floating-point registers. */
- gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
+ gdb_assert (ppc_floating_point_unit_p (gdbarch));
for (regno = tdep->ppc_fp0_regnum;
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
uint64_t *lr, uint64_t *ctr, uint32_t *xer,
uint32_t *fpscr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Verify that the size of the size of the IAR buffer is the
same as the raw size of the PC (in the register cache). If
they're not, then either GDB has been built incorrectly, or
there's some other kind of internal error. To be really safe,
we should check all of the sizes. */
- gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
+ gdb_assert (sizeof (*iar) == register_size
+ (gdbarch, gdbarch_pc_regnum (gdbarch)));
- if (regcache_valid_p (regcache, PC_REGNUM))
- regcache_raw_collect (regcache, PC_REGNUM, iar);
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))
+ regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
uint32_t *lr, uint32_t *ctr, uint32_t *xer,
uint32_t *fpscr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Verify that the size of the size of the IAR buffer is the
same as the raw size of the PC (in the register cache). If
they're not, then either GDB has been built incorrectly, or
there's some other kind of internal error. To be really safe,
we should check all of the sizes. */
- gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
+ gdb_assert (sizeof (*iar) == register_size (gdbarch,
+ gdbarch_pc_regnum (gdbarch)));
- if (regcache_valid_p (regcache, PC_REGNUM))
- regcache_raw_collect (regcache, PC_REGNUM, iar);
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))
+ regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
static void
store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
int status, i;
pthdb_context_t ctx;
uint32_t int32;
}
/* Collect floating-point register values from the regcache. */
- if (ppc_floating_point_unit_p (current_gdbarch))
+ if (ppc_floating_point_unit_p (gdbarch))
fill_fprs (regcache, ctx.fpr);
/* Special registers (always kept in ctx as 64 bits). */
fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
&tmp_xer, &tmp_fpscr);
- if (regcache_valid_p (regcache, PC_REGNUM))
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (gdbarch)))
ctx.iar = tmp_iar;
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
ctx.msr = tmp_msr;
store_regs_kernel_thread (const struct regcache *regcache, int regno,
pthdb_tid_t tid)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
uint64_t gprs64[ppc_num_gprs];
uint32_t gprs32[ppc_num_gprs];
double fprs[ppc_num_fprs];
/* Floating-point registers. */
- if (ppc_floating_point_unit_p (current_gdbarch)
+ if (ppc_floating_point_unit_p (gdbarch)
&& (regno == -1
|| (regno >= tdep->ppc_fp0_regnum
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{
/* Pre-fetch: some regs may not be in the cache. */
- ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
+ ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL);
fill_fprs (regcache, fprs);
- ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
+ ptrace32 (PTT_WRITE_FPRS, tid, (void *) fprs, 0, NULL);
}
/* Special-purpose registers. */
- if (regno == -1 || special_register_p (regno))
+ if (regno == -1 || special_register_p (gdbarch, regno))
{
if (arch64)
{
/* Clean up after the inferior exits. */
static void
-aix_thread_mourn_inferior (void)
+aix_thread_mourn_inferior (struct target_ops *ops)
{
pd_deactivate ();
- base_target.to_mourn_inferior ();
+ base_target.to_mourn_inferior (&base_target);
}
/* Return whether thread PID is still valid. */
"info threads" output. */
static char *
-aix_thread_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char *ret = NULL;
if (!PD_TID (ptid))
- return base_target.to_pid_to_str (ptid);
+ return base_target.to_pid_to_str (&base_target, ptid);
/* Free previous return value; a new one will be allocated by
xstrprintf(). */
add_target (&aix_thread_ops);
/* Notice when object files get loaded and unloaded. */
- target_new_objfile_chain = deprecated_target_new_objfile_hook;
- deprecated_target_new_objfile_hook = new_objfile;
+ observer_attach_new_objfile (new_objfile);
add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
_("Set debugging of AIX thread module."),