#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);
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. */
/* 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)
+ status->value.sig == TARGET_SIGNAL_TRAP
+ && read_pc_pid (ptid)
+ - gdbarch_decr_pc_after_break (current_gdbarch) == pd_brk_addr)
return pd_activate (0);
return pd_update (0);
/* Record that the 64-bit general-purpose registers contain VALS. */
static void
-supply_gprs64 (uint64_t *vals)
+supply_gprs64 (struct regcache *regcache, uint64_t *vals)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regno,
+ regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
(char *) (vals + regno));
}
/* Record that 32-bit register REGNO contains VAL. */
static void
-supply_reg32 (int regno, uint32_t val)
+supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
{
- regcache_raw_supply (current_regcache, regno, (char *) &val);
+ regcache_raw_supply (regcache, regno, (char *) &val);
}
/* Record that the floating-point registers contain VALS. */
static void
-supply_fprs (double *vals)
+supply_fprs (struct regcache *regcache, double *vals)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno;
gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
for (regno = 0; regno < ppc_num_fprs; regno++)
- regcache_raw_supply (current_regcache, regno + tdep->ppc_fp0_regnum,
+ regcache_raw_supply (regcache, regno + tdep->ppc_fp0_regnum,
(char *) (vals + regno));
}
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- return regno == PC_REGNUM
+ return regno == gdbarch_pc_regnum (current_gdbarch)
|| regno == tdep->ppc_ps_regnum
|| regno == tdep->ppc_cr_regnum
|| regno == tdep->ppc_lr_regnum
32-bit values. */
static void
-supply_sprs64 (uint64_t iar, uint64_t msr, uint32_t cr,
+supply_sprs64 (struct regcache *regcache,
+ uint64_t iar, uint64_t msr, uint32_t cr,
uint64_t lr, uint64_t ctr, uint32_t xer,
uint32_t fpscr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
- regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
- regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
- regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
- regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
- regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
+ regcache_raw_supply (regcache, gdbarch_pc_regnum (current_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);
+ regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
(char *) &fpscr);
}
values. */
static void
-supply_sprs32 (uint32_t iar, uint32_t msr, uint32_t cr,
+supply_sprs32 (struct regcache *regcache,
+ uint32_t iar, uint32_t msr, uint32_t cr,
uint32_t lr, uint32_t ctr, uint32_t xer,
uint32_t fpscr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
- regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
- regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
- regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
- regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
- regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
+ regcache_raw_supply (regcache, gdbarch_pc_regnum (current_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);
+ regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
(char *) &fpscr);
}
function. */
static void
-fetch_regs_user_thread (pthdb_pthread_t pdtid)
+fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int status, i;
/* General-purpose registers. */
if (arch64)
- supply_gprs64 (ctx.gpr);
+ supply_gprs64 (regcache, ctx.gpr);
else
for (i = 0; i < ppc_num_gprs; i++)
- supply_reg32 (tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
+ supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]);
/* Floating-point registers. */
if (ppc_floating_point_unit_p (current_gdbarch))
- supply_fprs (ctx.fpr);
+ supply_fprs (regcache, ctx.fpr);
/* Special registers. */
if (arch64)
- supply_sprs64 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
- ctx.fpscr);
+ supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
+ ctx.xer, ctx.fpscr);
else
- supply_sprs32 (ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, ctx.xer,
- ctx.fpscr);
+ supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr,
+ ctx.xer, ctx.fpscr);
}
/* Fetch register REGNO if != -1 or all registers otherwise from
be retrieved. */
static void
-fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
+fetch_regs_kernel_thread (struct regcache *regcache, int regno,
+ pthdb_tid_t tid)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
uint64_t gprs64[ppc_num_gprs];
if (!ptrace64aix (PTT_READ_GPRS, tid,
(unsigned long) gprs64, 0, NULL))
memset (gprs64, 0, sizeof (gprs64));
- supply_gprs64 (gprs64);
+ supply_gprs64 (regcache, gprs64);
}
else
{
if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
memset (gprs32, 0, sizeof (gprs32));
for (i = 0; i < ppc_num_gprs; i++)
- supply_reg32 (tdep->ppc_gp0_regnum + i, gprs32[i]);
+ supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
}
}
{
if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
memset (fprs, 0, sizeof (fprs));
- supply_fprs (fprs);
+ supply_fprs (regcache, fprs);
}
/* Special-purpose registers. */
if (!ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL))
memset (&sprs64, 0, sizeof (sprs64));
- supply_sprs64 (sprs64.pt_iar, sprs64.pt_msr, sprs64.pt_cr,
- sprs64.pt_lr, sprs64.pt_ctr, sprs64.pt_xer,
- sprs64.pt_fpscr);
+ supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
+ sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
+ sprs64.pt_xer, sprs64.pt_fpscr);
}
else
{
if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
memset (&sprs32, 0, sizeof (sprs32));
- supply_sprs32 (sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
+ supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
sprs32.pt_fpscr);
if (tdep->ppc_mq_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
+ regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
(char *) &sprs32.pt_mq);
}
}
thread/process specified by inferior_ptid. */
static void
-aix_thread_fetch_registers (int regno)
+aix_thread_fetch_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
- base_target.to_fetch_registers (regno);
+ base_target.to_fetch_registers (regcache, regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
- fetch_regs_user_thread (thread->private->pdtid);
+ fetch_regs_user_thread (regcache, thread->private->pdtid);
else
- fetch_regs_kernel_thread (regno, tid);
+ fetch_regs_kernel_thread (regcache, regno, tid);
}
}
/* Store the gp registers into an array of uint32_t or uint64_t. */
static void
-fill_gprs64 (uint64_t *vals)
+fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- if (register_cached (tdep->ppc_gp0_regnum + regno))
- regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
+ if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+ regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
vals + regno);
}
static void
-fill_gprs32 (uint32_t *vals)
+fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- if (register_cached (tdep->ppc_gp0_regnum + regno))
- regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + regno,
+ if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + regno))
+ regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
vals + regno);
}
/* Store the floating point registers into a double array. */
static void
-fill_fprs (double *vals)
+fill_fprs (const struct regcache *regcache, double *vals)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno;
for (regno = tdep->ppc_fp0_regnum;
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
regno++)
- if (register_cached (regno))
- regcache_raw_collect (current_regcache, regno, vals + regno);
+ if (regcache_valid_p (regcache, regno))
+ regcache_raw_collect (regcache, regno, vals + regno);
}
/* Store the special registers into the specified 64-bit and 32-bit
locations. */
static void
-fill_sprs64 (uint64_t *iar, uint64_t *msr, uint32_t *cr,
+fill_sprs64 (const struct regcache *regcache,
+ uint64_t *iar, uint64_t *msr, uint32_t *cr,
uint64_t *lr, uint64_t *ctr, uint32_t *xer,
uint32_t *fpscr)
{
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));
-
- if (register_cached (PC_REGNUM))
- regcache_raw_collect (current_regcache, PC_REGNUM, iar);
- if (register_cached (tdep->ppc_ps_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
- if (register_cached (tdep->ppc_cr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
- if (register_cached (tdep->ppc_lr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
- if (register_cached (tdep->ppc_ctr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
- if (register_cached (tdep->ppc_xer_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
+ gdb_assert (sizeof (*iar) == register_size
+ (current_gdbarch,
+ gdbarch_pc_regnum (current_gdbarch)));
+
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
+ regcache_raw_collect (regcache, gdbarch_pc_regnum (current_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))
+ regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+ if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+ if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+ if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
- && register_cached (tdep->ppc_fpscr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
+ && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
}
static void
-fill_sprs32 (unsigned long *iar, unsigned long *msr, unsigned long *cr,
- unsigned long *lr, unsigned long *ctr, unsigned long *xer,
- unsigned long *fpscr)
+fill_sprs32 (const struct regcache *regcache,
+ uint32_t *iar, uint32_t *msr, uint32_t *cr,
+ uint32_t *lr, uint32_t *ctr, uint32_t *xer,
+ uint32_t *fpscr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
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.
-
- If this assert() fails, the most likely reason is that GDB was
- built incorrectly. In order to make use of many of the header
- files in /usr/include/sys, GDB needs to be configured so that
- sizeof (long) == 4). */
- gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM));
-
- if (register_cached (PC_REGNUM))
- regcache_raw_collect (current_regcache, PC_REGNUM, iar);
- if (register_cached (tdep->ppc_ps_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_ps_regnum, msr);
- if (register_cached (tdep->ppc_cr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, cr);
- if (register_cached (tdep->ppc_lr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_lr_regnum, lr);
- if (register_cached (tdep->ppc_ctr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_ctr_regnum, ctr);
- if (register_cached (tdep->ppc_xer_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, xer);
+ we should check all of the sizes. */
+ gdb_assert (sizeof (*iar) == register_size (current_gdbarch,
+ gdbarch_pc_regnum
+ (current_gdbarch)));
+
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
+ regcache_raw_collect (regcache, gdbarch_pc_regnum (current_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))
+ regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+ if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+ if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+ if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
if (tdep->ppc_fpscr_regnum >= 0
- && register_cached (tdep->ppc_fpscr_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_fpscr_regnum, fpscr);
+ && regcache_valid_p (regcache, tdep->ppc_fpscr_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
}
/* Store all registers into pthread PDTID, which doesn't have a kernel
but I doubt it's worth the effort. */
static void
-store_regs_user_thread (pthdb_pthread_t pdtid)
+store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int status, i;
/* Collect general-purpose register values from the regcache. */
for (i = 0; i < ppc_num_gprs; i++)
- if (register_cached (tdep->ppc_gp0_regnum + i))
+ if (regcache_valid_p (regcache, tdep->ppc_gp0_regnum + i))
{
if (arch64)
{
- regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
+ regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
(void *) &int64);
ctx.gpr[i] = int64;
}
else
{
- regcache_raw_collect (current_regcache, tdep->ppc_gp0_regnum + i,
+ regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
(void *) &int32);
ctx.gpr[i] = int32;
}
/* Collect floating-point register values from the regcache. */
if (ppc_floating_point_unit_p (current_gdbarch))
- fill_fprs (ctx.fpr);
+ fill_fprs (regcache, ctx.fpr);
/* Special registers (always kept in ctx as 64 bits). */
if (arch64)
{
- fill_sprs64 (&ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, &ctx.xer,
- &ctx.fpscr);
+ fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr,
+ &ctx.xer, &ctx.fpscr);
}
else
{
/* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32.
- Solution: use 32-bit temp variables. (The assert() in fill_sprs32()
- will fail if the size of an unsigned long is incorrect. If this
- happens, GDB needs to be reconfigured so that longs are 32-bits.) */
- unsigned long tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
- tmp_fpscr;
-
- fill_sprs32 (&tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, &tmp_xer,
- &tmp_fpscr);
- if (register_cached (PC_REGNUM))
+ Solution: use 32-bit temp variables. */
+ uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
+ tmp_fpscr;
+
+ fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
+ &tmp_xer, &tmp_fpscr);
+ if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
ctx.iar = tmp_iar;
- if (register_cached (tdep->ppc_ps_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
ctx.msr = tmp_msr;
- if (register_cached (tdep->ppc_cr_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
ctx.cr = tmp_cr;
- if (register_cached (tdep->ppc_lr_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_lr_regnum))
ctx.lr = tmp_lr;
- if (register_cached (tdep->ppc_ctr_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_ctr_regnum))
ctx.ctr = tmp_ctr;
- if (register_cached (tdep->ppc_xer_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
ctx.xer = tmp_xer;
- if (register_cached (tdep->ppc_xer_regnum))
+ if (regcache_valid_p (regcache, tdep->ppc_xer_regnum))
ctx.fpscr = tmp_fpscr;
}
group. */
static void
-store_regs_kernel_thread (int regno, pthdb_tid_t tid)
+store_regs_kernel_thread (const struct regcache *regcache, int regno,
+ pthdb_tid_t tid)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
uint64_t gprs64[ppc_num_gprs];
{
/* Pre-fetch: some regs may not be in the cache. */
ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
- fill_gprs64 (gprs64);
+ fill_gprs64 (regcache, gprs64);
ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
}
else
{
/* Pre-fetch: some regs may not be in the cache. */
ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
- fill_gprs32 (gprs32);
+ fill_gprs32 (regcache, gprs32);
ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
}
}
{
/* Pre-fetch: some regs may not be in the cache. */
ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);
- fill_fprs (fprs);
+ fill_fprs (regcache, fprs);
ptrace32 (PTT_WRITE_FPRS, tid, (int *) fprs, 0, NULL);
}
/* Pre-fetch: some registers won't be in the cache. */
ptrace64aix (PTT_READ_SPRS, tid,
(unsigned long) &sprs64, 0, NULL);
- fill_sprs64 (&sprs64.pt_iar, &sprs64.pt_msr, &sprs64.pt_cr,
- &sprs64.pt_lr, &sprs64.pt_ctr, &sprs64.pt_xer,
- &sprs64.pt_fpscr);
+ fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr,
+ &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr,
+ &sprs64.pt_xer, &sprs64.pt_fpscr);
ptrace64aix (PTT_WRITE_SPRS, tid,
(unsigned long) &sprs64, 0, NULL);
}
else
{
+ /* The contents of "struct ptspr" were declared as "unsigned
+ long" up to AIX 5.2, but are "unsigned int" since 5.3.
+ Use temporaries to work around this problem. Also, add an
+ assert here to make sure we fail if the system header files
+ use "unsigned long", and the size of that type is not what
+ the headers expect. */
+ uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
+ tmp_fpscr;
+
+ gdb_assert (sizeof (sprs32.pt_iar) == 4);
+
/* Pre-fetch: some registers won't be in the cache. */
ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
- fill_sprs32 (&sprs32.pt_iar, &sprs32.pt_msr, &sprs32.pt_cr,
- &sprs32.pt_lr, &sprs32.pt_ctr, &sprs32.pt_xer,
- &sprs32.pt_fpscr);
+ fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
+ &tmp_ctr, &tmp_xer, &tmp_fpscr);
+
+ sprs32.pt_iar = tmp_iar;
+ sprs32.pt_msr = tmp_msr;
+ sprs32.pt_cr = tmp_cr;
+ sprs32.pt_lr = tmp_lr;
+ sprs32.pt_ctr = tmp_ctr;
+ sprs32.pt_xer = tmp_xer;
+ sprs32.pt_fpscr = tmp_fpscr;
if (tdep->ppc_mq_regnum >= 0)
- if (register_cached (tdep->ppc_mq_regnum))
- regcache_raw_collect (current_regcache, tdep->ppc_mq_regnum,
+ if (regcache_valid_p (regcache, tdep->ppc_mq_regnum))
+ regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
&sprs32.pt_mq);
ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
thread/process specified by inferior_ptid. */
static void
-aix_thread_store_registers (int regno)
+aix_thread_store_registers (struct regcache *regcache, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
if (!PD_TID (inferior_ptid))
- base_target.to_store_registers (regno);
+ base_target.to_store_registers (regcache, regno);
else
{
thread = find_thread_pid (inferior_ptid);
tid = thread->private->tid;
if (tid == PTHDB_INVALID_TID)
- store_regs_user_thread (thread->private->pdtid);
+ store_regs_user_thread (regcache, thread->private->pdtid);
else
- store_regs_kernel_thread (regno, tid);
+ store_regs_kernel_thread (regcache, regno, tid);
}
}
-/* Transfer LEN bytes of memory from GDB address MYADDR to target
- address MEMADDR if WRITE and vice versa otherwise. */
+/* Attempt a transfer all LEN bytes starting at OFFSET between the
+ inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
+ Return the number of bytes actually transferred. */
-static int
-aix_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib,
- struct target_ops *target)
+static LONGEST
+aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
- int n;
- struct cleanup *cleanup = save_inferior_ptid ();
+ struct cleanup *old_chain = save_inferior_ptid ();
+ LONGEST xfer;
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- n = base_target.deprecated_xfer_memory (memaddr, myaddr, len,
- write, attrib, &base_target);
- do_cleanups (cleanup);
+ xfer = base_target.to_xfer_partial (ops, object, annex,
+ readbuf, writebuf, offset, len);
- return n;
+ do_cleanups (old_chain);
+ return xfer;
}
/* Kill and forget about the inferior process. */
if (tid != PTHDB_INVALID_TID)
/* i18n: Like "thread-identifier %d, [state] running, suspended" */
- fprintf_unfiltered (buf, _("tid %d"), tid);
+ fprintf_unfiltered (buf, _("tid %d"), (int)tid);
status = pthdb_pthread_state (pd_session, pdtid, &state);
if (status != PTHDB_SUCCESS)
aix_thread_ops.to_wait = aix_thread_wait;
aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
aix_thread_ops.to_store_registers = aix_thread_store_registers;
- aix_thread_ops.deprecated_xfer_memory = aix_thread_xfer_memory;
+ aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
/* No need for aix_thread_ops.to_create_inferior, because we activate thread
debugging when the inferior reaches pd_brk_addr. */
aix_thread_ops.to_kill = aix_thread_kill;
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."),