mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-04-24 14:53:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

* ppc-linux-nat.c (right_fill_reg): Delete.

Browse Source 
(supply_gregset): Use ppc_supply_gregset.
	(supply_fpregset): Use ppc_supply_fpregset.
	(fill_gregset): Use ppc_collect_gregset.
	(fill_fpregset): Use ppc_collect_fpregset.
	* ppc-linux-tdep.c (PPC_LINUX_PT_*): Don't define.
	(right_supply_register, ppc_linux_supply_gregset): Delete.
	(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): Delete.
	(ppc_linux_supply_fpregset): Delete.
	(ppc_linux_collect_gregset): New function.
	(ppc32_linux_reg_offsets, ppc64_linux_reg_offsets): New.
	(ppc32_linux_gregset, ppc64_linux_gregset): Update to use reg offsets,
	ppc_linux_supply_gregset, and ppc_collect_gregset.
	(ppc_linux_fpregset): Rename to ppc32_linux_fpregset and update.
	(ppc_linux_gregset, ppc_linux_fpregset): New functions.
	(ppc_linux_regset_from_core_section): Update.
	* ppc-tdep.h (ppc_linux_gregset, ppc_linux_fpregset): Declare.
	(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Delete.
	(struct ppc_reg_offsets): Add gpr_size, xr_size, fpscr_size fields.
	* ppcobsd-tdep.c (ppcobsd_supply_gregset): Delete FIXME and assert.
	(ppcobsd_collect_gregset): Likewise.
	(_initialize_ppcnbsd_tdep): Init gpr_size, xr_size, fpscr_size.
	* ppcnbsd-tdep.c (_initialize_ppcobsd_tdep): Likewise.
	* ppcobsd-nat.c (_initialize_ppcobsd_nat): Likewise.
	* rs6000-aix-tdep.c (rs6000_aix32_reg_offsets): Likewise.
	(rs6000_aix64_reg_offsets): Likewise.
	(rs6000_aix_supply_regset): Call ppc_supply_fpregset without testing
	ppc_floating_point_unit_p.
	(rs6000_aix_collect_regset): Similarly.
	* rs6000-tdep.c (ppc_supply_reg): Add regsize param.  Adjust offset
	when regsize is larger than regcache register size.
	(ppc_collect_reg): Similarly zero pad when regsize is larger than
	regcache register size.
	(ppc_greg_offset): New function, split out from..
	(ppc_supply_gregset): ..here.  Separate code handling all regs from
	single reg case.  Correct xer offset.
	(ppc_fpreg_offset): New function, split out from..
	(ppc_supply_fpregset): ..here.  Separate code handling all regs from
	single reg case.
	(ppc_collect_gregset, ppc_collect_fpregset): Likewise.
	(ppc_supply_fpregset, ppc_collect_fpregset): Don't assert we have
	a fp unit, instead return if no fp.
This commit is contained in:
Alan Modra 2007-08-30 13:13:59 +00:00
parent 2db6cde736
commit f2db237aa1
9 changed files with 359 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
gdb/ChangeLog
View File

@ -1,3 +1,48 @@
2007-08-30 Alan Modra <amodra@bigpond.net.au>
* ppc-linux-nat.c (right_fill_reg): Delete.
(supply_gregset): Use ppc_supply_gregset.
(supply_fpregset): Use ppc_supply_fpregset.
(fill_gregset): Use ppc_collect_gregset.
(fill_fpregset): Use ppc_collect_fpregset.
* ppc-linux-tdep.c (PPC_LINUX_PT_*): Don't define.
(right_supply_register, ppc_linux_supply_gregset): Delete.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): Delete.
(ppc_linux_supply_fpregset): Delete.
(ppc_linux_collect_gregset): New function.
(ppc32_linux_reg_offsets, ppc64_linux_reg_offsets): New.
(ppc32_linux_gregset, ppc64_linux_gregset): Update to use reg offsets,
ppc_linux_supply_gregset, and ppc_collect_gregset.
(ppc_linux_fpregset): Rename to ppc32_linux_fpregset and update.
(ppc_linux_gregset, ppc_linux_fpregset): New functions.
(ppc_linux_regset_from_core_section): Update.
* ppc-tdep.h (ppc_linux_gregset, ppc_linux_fpregset): Declare.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Delete.
(struct ppc_reg_offsets): Add gpr_size, xr_size, fpscr_size fields.
* ppcobsd-tdep.c (ppcobsd_supply_gregset): Delete FIXME and assert.
(ppcobsd_collect_gregset): Likewise.
(_initialize_ppcnbsd_tdep): Init gpr_size, xr_size, fpscr_size.
* ppcnbsd-tdep.c (_initialize_ppcobsd_tdep): Likewise.
* ppcobsd-nat.c (_initialize_ppcobsd_nat): Likewise.
* rs6000-aix-tdep.c (rs6000_aix32_reg_offsets): Likewise.
(rs6000_aix64_reg_offsets): Likewise.
(rs6000_aix_supply_regset): Call ppc_supply_fpregset without testing
ppc_floating_point_unit_p.
(rs6000_aix_collect_regset): Similarly.
* rs6000-tdep.c (ppc_supply_reg): Add regsize param. Adjust offset
when regsize is larger than regcache register size.
(ppc_collect_reg): Similarly zero pad when regsize is larger than
regcache register size.
(ppc_greg_offset): New function, split out from..
(ppc_supply_gregset): ..here. Separate code handling all regs from
single reg case. Correct xer offset.
(ppc_fpreg_offset): New function, split out from..
(ppc_supply_fpregset): ..here. Separate code handling all regs from
single reg case.
(ppc_collect_gregset, ppc_collect_fpregset): Likewise.
(ppc_supply_fpregset, ppc_collect_fpregset): Don't assert we have
a fp unit, instead return if no fp.
2007-08-29 Jim Blandy <jimb@codesourcery.com> 2007-08-29 Jim Blandy <jimb@codesourcery.com>
* breakpoint.c (watch_command_1): Remove '#ifdef HPUXHPPA' block; * breakpoint.c (watch_command_1): Remove '#ifdef HPUXHPPA' block;

91
gdb/ppc-linux-nat.c
View File

@ -901,101 +901,48 @@ ppc_linux_store_inferior_registers (struct regcache *regcache, int regno)
store_ppc_registers (regcache, tid); store_ppc_registers (regcache, tid);
} }
/* Functions for transferring registers between a gregset_t or fpregset_t
(see sys/ucontext.h) and gdb's regcache. The word size is that used
by the ptrace interface, not the current program's ABI. eg. If a
powerpc64-linux gdb is being used to debug a powerpc32-linux app, we
read or write 64-bit gregsets. This is to suit the host libthread_db. */
void void
supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{ {
/* NOTE: cagney/2003-11-25: This is the word size used by the ptrace const struct regset *regset = ppc_linux_gregset (sizeof (long));
interface, and not the wordsize of the program's ABI. */
int wordsize = sizeof (long);
ppc_linux_supply_gregset (regcache, -1, gregsetp,
sizeof (gdb_gregset_t), wordsize);
}
static void ppc_supply_gregset (regset, regcache, -1, gregsetp, sizeof (*gregsetp));
right_fill_reg (const struct regcache *regcache, int regnum, void *reg)
{
/* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
interface, and not the wordsize of the program's ABI. */
int wordsize = sizeof (long);
/* Right fill the register. */
regcache_raw_collect (regcache, regnum,
((bfd_byte *) reg
+ wordsize
- register_size (current_gdbarch, regnum)));
} }
void void
fill_gregset (const struct regcache *regcache, fill_gregset (const struct regcache *regcache,
gdb_gregset_t *gregsetp, int regno) gdb_gregset_t *gregsetp, int regno)
{ {
int regi; const struct regset *regset = ppc_linux_gregset (sizeof (long));
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
const int elf_ngreg = 48;
if (regno == -1)
/* Start with zeros. */ memset (gregsetp, 0, sizeof (*gregsetp));
memset (regp, 0, elf_ngreg * sizeof (*regp)); ppc_collect_gregset (regset, regcache, regno, gregsetp, sizeof (*gregsetp));
for (regi = 0; regi < ppc_num_gprs; regi++)
{
if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi)
right_fill_reg (regcache, tdep->ppc_gp0_regnum + regi,
(regp + PT_R0 + regi));
}
if ((regno == -1) || regno == gdbarch_pc_regnum (current_gdbarch))
right_fill_reg (regcache, gdbarch_pc_regnum (current_gdbarch),
regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
right_fill_reg (regcache, tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_raw_collect (regcache, tdep->ppc_cr_regnum,
regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_raw_collect (regcache, tdep->ppc_xer_regnum,
regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
right_fill_reg (regcache, tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
right_fill_reg (regcache, tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
right_fill_reg (regcache, tdep->ppc_ps_regnum, regp + PT_MSR);
} }
void void
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp) supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp)
{ {
ppc_linux_supply_fpregset (NULL, regcache, -1, fpregsetp, const struct regset *regset = ppc_linux_fpregset ();
sizeof (gdb_fpregset_t));
ppc_supply_fpregset (regset, regcache, -1,
fpregsetp, sizeof (*fpregsetp));
} }
/* Given a pointer to a floating point register set in /proc format
(fpregset_t *), update the register specified by REGNO from gdb's
idea of the current floating point register set. If REGNO is -1,
update them all. */
void void
fill_fpregset (const struct regcache *regcache, fill_fpregset (const struct regcache *regcache,
gdb_fpregset_t *fpregsetp, int regno) gdb_fpregset_t *fpregsetp, int regno)
{ {
int regi; const struct regset *regset = ppc_linux_fpregset ();
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
bfd_byte *fpp = (void *) fpregsetp;
if (ppc_floating_point_unit_p (current_gdbarch)) ppc_collect_fpregset (regset, regcache, regno,
{ fpregsetp, sizeof (*fpregsetp));
for (regi = 0; regi < ppc_num_fprs; regi++)
{
if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
regcache_raw_collect (regcache, tdep->ppc_fp0_regnum + regi,
fpp + 8 * regi);
}
if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
right_fill_reg (regcache, tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
} }
void _initialize_ppc_linux_nat (void); void _initialize_ppc_linux_nat (void);

212
gdb/ppc-linux-tdep.c
View File

@ -38,51 +38,6 @@
#include "frame-unwind.h" #include "frame-unwind.h"
#include "tramp-frame.h" #include "tramp-frame.h"
/* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
#define PPC_LINUX_PT_R0 0
#define PPC_LINUX_PT_R1 1
#define PPC_LINUX_PT_R2 2
#define PPC_LINUX_PT_R3 3
#define PPC_LINUX_PT_R4 4
#define PPC_LINUX_PT_R5 5
#define PPC_LINUX_PT_R6 6
#define PPC_LINUX_PT_R7 7
#define PPC_LINUX_PT_R8 8
#define PPC_LINUX_PT_R9 9
#define PPC_LINUX_PT_R10 10
#define PPC_LINUX_PT_R11 11
#define PPC_LINUX_PT_R12 12
#define PPC_LINUX_PT_R13 13
#define PPC_LINUX_PT_R14 14
#define PPC_LINUX_PT_R15 15
#define PPC_LINUX_PT_R16 16
#define PPC_LINUX_PT_R17 17
#define PPC_LINUX_PT_R18 18
#define PPC_LINUX_PT_R19 19
#define PPC_LINUX_PT_R20 20
#define PPC_LINUX_PT_R21 21
#define PPC_LINUX_PT_R22 22
#define PPC_LINUX_PT_R23 23
#define PPC_LINUX_PT_R24 24
#define PPC_LINUX_PT_R25 25
#define PPC_LINUX_PT_R26 26
#define PPC_LINUX_PT_R27 27
#define PPC_LINUX_PT_R28 28
#define PPC_LINUX_PT_R29 29
#define PPC_LINUX_PT_R30 30
#define PPC_LINUX_PT_R31 31
#define PPC_LINUX_PT_NIP 32
#define PPC_LINUX_PT_MSR 33
#define PPC_LINUX_PT_CTR 35
#define PPC_LINUX_PT_LNK 36
#define PPC_LINUX_PT_XER 37
#define PPC_LINUX_PT_CCR 38
#define PPC_LINUX_PT_MQ 39
#define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */
#define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
#define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
static CORE_ADDR static CORE_ADDR
ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{ {
@ -660,99 +615,102 @@ ppc_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
return addr; return addr;
} }
static void /* This wrapper clears areas in the linux gregset not written by
right_supply_register (struct regcache *regcache, int wordsize, int regnum, ppc_collect_gregset. */
const bfd_byte *buf)
{
regcache_raw_supply (regcache, regnum,
(buf + wordsize - register_size (current_gdbarch, regnum)));
}
/* Extract the register values found in the WORDSIZED ABI GREGSET,
storing their values in REGCACHE. Note that some are left-aligned,
while others are right aligned. */
void
ppc_linux_supply_gregset (struct regcache *regcache,
int regnum, const void *gregs, size_t size,
int wordsize)
{
int regi;
struct gdbarch *regcache_arch = get_regcache_arch (regcache);
struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
const bfd_byte *buf = gregs;
for (regi = 0; regi < ppc_num_gprs; regi++)
right_supply_register (regcache, wordsize,
regcache_tdep->ppc_gp0_regnum + regi,
buf + wordsize * regi);
right_supply_register (regcache, wordsize, gdbarch_pc_regnum (regcache_arch),
buf + wordsize * PPC_LINUX_PT_NIP);
right_supply_register (regcache, wordsize, regcache_tdep->ppc_lr_regnum,
buf + wordsize * PPC_LINUX_PT_LNK);
regcache_raw_supply (regcache, regcache_tdep->ppc_cr_regnum,
buf + wordsize * PPC_LINUX_PT_CCR);
regcache_raw_supply (regcache, regcache_tdep->ppc_xer_regnum,
buf + wordsize * PPC_LINUX_PT_XER);
regcache_raw_supply (regcache, regcache_tdep->ppc_ctr_regnum,
buf + wordsize * PPC_LINUX_PT_CTR);
if (regcache_tdep->ppc_mq_regnum != -1)
right_supply_register (regcache, wordsize, regcache_tdep->ppc_mq_regnum,
buf + wordsize * PPC_LINUX_PT_MQ);
right_supply_register (regcache, wordsize, regcache_tdep->ppc_ps_regnum,
buf + wordsize * PPC_LINUX_PT_MSR);
}
static void static void
ppc32_linux_supply_gregset (const struct regset *regset, ppc_linux_collect_gregset (const struct regset *regset,
struct regcache *regcache, const struct regcache *regcache,
int regnum, const void *gregs, size_t size) int regnum, void *gregs, size_t len)
{ {
ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4); if (regnum == -1)
memset (gregs, 0, len);
ppc_collect_gregset (regset, regcache, regnum, gregs, len);
} }
static struct regset ppc32_linux_gregset = { /* Regset descriptions. */
NULL, ppc32_linux_supply_gregset static const struct ppc_reg_offsets ppc32_linux_reg_offsets =
{
/* General-purpose registers. */
/* .r0_offset = */ 0,
/* .gpr_size = */ 4,
/* .xr_size = */ 4,
/* .pc_offset = */ 128,
/* .ps_offset = */ 132,
/* .cr_offset = */ 152,
/* .lr_offset = */ 144,
/* .ctr_offset = */ 140,
/* .xer_offset = */ 148,
/* .mq_offset = */ 156,
/* Floating-point registers. */
/* .f0_offset = */ 0,
/* .fpscr_offset = */ 256,
/* .fpscr_size = */ 8,
/* AltiVec registers. */
/* .vr0_offset = */ 0,
/* .vrsave_offset = */ 512,
/* .vscr_offset = */ 512 + 12
};
static const struct ppc_reg_offsets ppc64_linux_reg_offsets =
{
/* General-purpose registers. */
/* .r0_offset = */ 0,
/* .gpr_size = */ 8,
/* .xr_size = */ 8,
/* .pc_offset = */ 256,
/* .ps_offset = */ 264,
/* .cr_offset = */ 304,
/* .lr_offset = */ 288,
/* .ctr_offset = */ 280,
/* .xer_offset = */ 296,
/* .mq_offset = */ 312,
/* Floating-point registers. */
/* .f0_offset = */ 0,
/* .fpscr_offset = */ 256,
/* .fpscr_size = */ 8,
/* AltiVec registers. */
/* .vr0_offset = */ 0,
/* .vrsave_offset = */ 528,
/* .vscr_offset = */ 512 + 12
};
static const struct regset ppc32_linux_gregset = {
&ppc32_linux_reg_offsets,
ppc_supply_gregset,
ppc_linux_collect_gregset,
NULL
}; };
static void static const struct regset ppc64_linux_gregset = {
ppc64_linux_supply_gregset (const struct regset *regset, &ppc64_linux_reg_offsets,
struct regcache * regcache, ppc_supply_gregset,
int regnum, const void *gregs, size_t size) ppc_linux_collect_gregset,
{ NULL
ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
}
static struct regset ppc64_linux_gregset = {
NULL, ppc64_linux_supply_gregset
}; };
void static const struct regset ppc32_linux_fpregset = {
ppc_linux_supply_fpregset (const struct regset *regset, &ppc32_linux_reg_offsets,
struct regcache * regcache, ppc_supply_fpregset,
int regnum, const void *fpset, size_t size) ppc_collect_fpregset,
NULL
};
const struct regset *
ppc_linux_gregset (int wordsize)
{ {
int regi; return wordsize == 8 ? &ppc64_linux_gregset : &ppc32_linux_gregset;
struct gdbarch *regcache_arch = get_regcache_arch (regcache);
struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
const bfd_byte *buf = fpset;
if (! ppc_floating_point_unit_p (regcache_arch))
return;
for (regi = 0; regi < ppc_num_fprs; regi++)
regcache_raw_supply (regcache,
regcache_tdep->ppc_fp0_regnum + regi,
buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last
doubleword in the fpregset. */
regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
buf + 8 * 32 + 4);
} }
static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset }; const struct regset *
ppc_linux_fpregset (void)
{
return &ppc32_linux_fpregset;
}
static const struct regset * static const struct regset *
ppc_linux_regset_from_core_section (struct gdbarch *core_arch, ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
@ -767,7 +725,7 @@ ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
return &ppc64_linux_gregset; return &ppc64_linux_gregset;
} }
if (strcmp (sect_name, ".reg2") == 0) if (strcmp (sect_name, ".reg2") == 0)
return &ppc_linux_fpregset; return &ppc32_linux_fpregset;
return NULL; return NULL;
} }

11
gdb/ppc-tdep.h
View File

@ -56,12 +56,8 @@ CORE_ADDR ppc64_sysv_abi_adjust_breakpoint_address (struct gdbarch *gdbarch,
CORE_ADDR bpaddr); CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt); int ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void); struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
void ppc_linux_supply_gregset (struct regcache *regcache, const struct regset *ppc_linux_gregset (int);
int regnum, const void *gregs, size_t size, const struct regset *ppc_linux_fpregset (void);
int wordsize);
void ppc_linux_supply_fpregset (const struct regset *regset,
struct regcache *regcache,
int regnum, const void *gregs, size_t size);
enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, enum return_value_convention ppc64_sysv_abi_return_value (struct gdbarch *gdbarch,
struct type *valtype, struct type *valtype,
@ -83,6 +79,8 @@ struct ppc_reg_offsets
{ {
/* General-purpose registers. */ /* General-purpose registers. */
int r0_offset; int r0_offset;
int gpr_size; /* size for r0-31, pc, ps, lr, ctr. */
int xr_size; /* size for cr, xer, mq. */
int pc_offset; int pc_offset;
int ps_offset; int ps_offset;
int cr_offset; int cr_offset;
@ -94,6 +92,7 @@ struct ppc_reg_offsets
/* Floating-point registers. */ /* Floating-point registers. */
int f0_offset; int f0_offset;
int fpscr_offset; int fpscr_offset;
int fpscr_size;
/* AltiVec registers. */ /* AltiVec registers. */
int vr0_offset; int vr0_offset;

3
gdb/ppcnbsd-tdep.c
View File

@ -213,6 +213,8 @@ _initialize_ppcnbsd_tdep (void)
{ {
/* General-purpose registers. */ /* General-purpose registers. */
ppcnbsd_reg_offsets.r0_offset = 0; ppcnbsd_reg_offsets.r0_offset = 0;
ppcnbsd_reg_offsets.gpr_size = 4;
ppcnbsd_reg_offsets.xr_size = 4;
ppcnbsd_reg_offsets.lr_offset = 128; ppcnbsd_reg_offsets.lr_offset = 128;
ppcnbsd_reg_offsets.cr_offset = 132; ppcnbsd_reg_offsets.cr_offset = 132;
ppcnbsd_reg_offsets.xer_offset = 136; ppcnbsd_reg_offsets.xer_offset = 136;
@ -224,6 +226,7 @@ _initialize_ppcnbsd_tdep (void)
/* Floating-point registers. */ /* Floating-point registers. */
ppcnbsd_reg_offsets.f0_offset = 0; ppcnbsd_reg_offsets.f0_offset = 0;
ppcnbsd_reg_offsets.fpscr_offset = 256; ppcnbsd_reg_offsets.fpscr_offset = 256;
ppcnbsd_reg_offsets.fpscr_size = 4;
/* AltiVec registers. */ /* AltiVec registers. */
ppcnbsd_reg_offsets.vr0_offset = 0; ppcnbsd_reg_offsets.vr0_offset = 0;

3
gdb/ppcobsd-nat.c
View File

@ -198,6 +198,8 @@ _initialize_ppcobsd_nat (void)
/* General-purpose registers. */ /* General-purpose registers. */
ppcobsd_reg_offsets.r0_offset = offsetof (struct reg, gpr); ppcobsd_reg_offsets.r0_offset = offsetof (struct reg, gpr);
ppcobsd_reg_offsets.gpr_size = 4;
ppcobsd_reg_offsets.xr_size = 4;
ppcobsd_reg_offsets.pc_offset = offsetof (struct reg, pc); ppcobsd_reg_offsets.pc_offset = offsetof (struct reg, pc);
ppcobsd_reg_offsets.ps_offset = offsetof (struct reg, ps); ppcobsd_reg_offsets.ps_offset = offsetof (struct reg, ps);
ppcobsd_reg_offsets.cr_offset = offsetof (struct reg, cnd); ppcobsd_reg_offsets.cr_offset = offsetof (struct reg, cnd);
@ -212,6 +214,7 @@ _initialize_ppcobsd_nat (void)
#ifdef PT_GETFPREGS #ifdef PT_GETFPREGS
ppcobsd_fpreg_offsets.f0_offset = offsetof (struct fpreg, fpr); ppcobsd_fpreg_offsets.f0_offset = offsetof (struct fpreg, fpr);
ppcobsd_fpreg_offsets.fpscr_offset = offsetof (struct fpreg, fpscr); ppcobsd_fpreg_offsets.fpscr_offset = offsetof (struct fpreg, fpscr);
ppcobsd_fpreg_offsets.fpscr_size = 4;
#endif #endif
/* AltiVec registers. */ /* AltiVec registers. */

27
gdb/ppcobsd-tdep.c
View File

@ -51,18 +51,6 @@ ppcobsd_supply_gregset (const struct regset *regset,
struct regcache *regcache, int regnum, struct regcache *regcache, int regnum,
const void *gregs, size_t len) const void *gregs, size_t len)
{ {
/* FIXME: jimb/2004-05-05: Some PPC variants don't have floating
point registers. Traditionally, GDB's register set has still
listed the floating point registers for such machines, so this
code is harmless. However, the new E500 port actually omits the
floating point registers entirely from the register set --- they
don't even have register numbers assigned to them.
It's not clear to me how best to update this code, so this assert
will alert the first person to encounter the OpenBSD/E500
combination to the problem. */
gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
ppc_supply_gregset (regset, regcache, regnum, gregs, len); ppc_supply_gregset (regset, regcache, regnum, gregs, len);
ppc_supply_fpregset (regset, regcache, regnum, gregs, len); ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
} }
@ -77,18 +65,6 @@ ppcobsd_collect_gregset (const struct regset *regset,
const struct regcache *regcache, int regnum, const struct regcache *regcache, int regnum,
void *gregs, size_t len) void *gregs, size_t len)
{ {
/* FIXME: jimb/2004-05-05: Some PPC variants don't have floating
point registers. Traditionally, GDB's register set has still
listed the floating point registers for such machines, so this
code is harmless. However, the new E500 port actually omits the
floating point registers entirely from the register set --- they
don't even have register numbers assigned to them.
It's not clear to me how best to update this code, so this assert
will alert the first person to encounter the OpenBSD/E500
combination to the problem. */
gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
ppc_collect_gregset (regset, regcache, regnum, gregs, len); ppc_collect_gregset (regset, regcache, regnum, gregs, len);
ppc_collect_fpregset (regset, regcache, regnum, gregs, len); ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
} }
@ -331,6 +307,8 @@ _initialize_ppcobsd_tdep (void)
{ {
/* General-purpose registers. */ /* General-purpose registers. */
ppcobsd_reg_offsets.r0_offset = 0; ppcobsd_reg_offsets.r0_offset = 0;
ppcobsd_reg_offsets.gpr_size = 4;
ppcobsd_reg_offsets.xr_size = 4;
ppcobsd_reg_offsets.pc_offset = 384; ppcobsd_reg_offsets.pc_offset = 384;
ppcobsd_reg_offsets.ps_offset = 388; ppcobsd_reg_offsets.ps_offset = 388;
ppcobsd_reg_offsets.cr_offset = 392; ppcobsd_reg_offsets.cr_offset = 392;
@ -354,5 +332,6 @@ _initialize_ppcobsd_tdep (void)
/* Floating-point registers. */ /* Floating-point registers. */
ppcobsd_reg_offsets.f0_offset = 0; ppcobsd_reg_offsets.f0_offset = 0;
ppcobsd_reg_offsets.fpscr_offset = 256; ppcobsd_reg_offsets.fpscr_offset = 256;
ppcobsd_reg_offsets.fpscr_size = 4;
} }
} }

14
gdb/rs6000-aix-tdep.c
View File

@ -34,6 +34,8 @@ static struct ppc_reg_offsets rs6000_aix32_reg_offsets =
{ {
/* General-purpose registers. */ /* General-purpose registers. */
208, /* r0_offset */ 208, /* r0_offset */
4, /* gpr_size */
4, /* xr_size */
24, /* pc_offset */ 24, /* pc_offset */
28, /* ps_offset */ 28, /* ps_offset */
32, /* cr_offset */ 32, /* cr_offset */
@ -45,6 +47,7 @@ static struct ppc_reg_offsets rs6000_aix32_reg_offsets =
/* Floating-point registers. */ /* Floating-point registers. */
336, /* f0_offset */ 336, /* f0_offset */
56, /* fpscr_offset */ 56, /* fpscr_offset */
4, /* fpscr_size */
/* AltiVec registers. */ /* AltiVec registers. */
-1, /* vr0_offset */ -1, /* vr0_offset */
@ -56,6 +59,8 @@ static struct ppc_reg_offsets rs6000_aix64_reg_offsets =
{ {
/* General-purpose registers. */ /* General-purpose registers. */
0, /* r0_offset */ 0, /* r0_offset */
8, /* gpr_size */
4, /* xr_size */
264, /* pc_offset */ 264, /* pc_offset */
256, /* ps_offset */ 256, /* ps_offset */
288, /* cr_offset */ 288, /* cr_offset */
@ -67,6 +72,7 @@ static struct ppc_reg_offsets rs6000_aix64_reg_offsets =
/* Floating-point registers. */ /* Floating-point registers. */
312, /* f0_offset */ 312, /* f0_offset */
296, /* fpscr_offset */ 296, /* fpscr_offset */
4, /* fpscr_size */
/* AltiVec registers. */ /* AltiVec registers. */
-1, /* vr0_offset */ -1, /* vr0_offset */
@ -85,9 +91,7 @@ rs6000_aix_supply_regset (const struct regset *regset,
const void *gregs, size_t len) const void *gregs, size_t len)
{ {
ppc_supply_gregset (regset, regcache, regnum, gregs, len); ppc_supply_gregset (regset, regcache, regnum, gregs, len);
ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
if (ppc_floating_point_unit_p (get_regcache_arch (regcache)))
ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
} }
/* Collect register REGNUM in the general-purpose register set /* Collect register REGNUM in the general-purpose register set
@ -101,9 +105,7 @@ rs6000_aix_collect_regset (const struct regset *regset,
void *gregs, size_t len) void *gregs, size_t len)
{ {
ppc_collect_gregset (regset, regcache, regnum, gregs, len); ppc_collect_gregset (regset, regcache, regnum, gregs, len);
ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
if (ppc_floating_point_unit_p (get_regcache_arch (regcache)))
ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
} }
/* AIX register set. */ /* AIX register set. */

273
gdb/rs6000-tdep.c
View File

@ -302,20 +302,107 @@ rs6000_register_sim_regno (int reg)
/* Register set support functions. */ /* Register set support functions. */
/* REGS + OFFSET contains register REGNUM in a field REGSIZE wide.
Write the register to REGCACHE. */
static void static void
ppc_supply_reg (struct regcache *regcache, int regnum, ppc_supply_reg (struct regcache *regcache, int regnum,
const gdb_byte *regs, size_t offset) const gdb_byte *regs, size_t offset, int regsize)
{ {
if (regnum != -1 && offset != -1) if (regnum != -1 && offset != -1)
regcache_raw_supply (regcache, regnum, regs + offset); {
if (regsize > 4)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int gdb_regsize = register_size (gdbarch, regnum);
if (gdb_regsize < regsize
&& gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
offset += regsize - gdb_regsize;
}
regcache_raw_supply (regcache, regnum, regs + offset);
}
} }
/* Read register REGNUM from REGCACHE and store to REGS + OFFSET
in a field REGSIZE wide. Zero pad as necessary. */
static void static void
ppc_collect_reg (const struct regcache *regcache, int regnum, ppc_collect_reg (const struct regcache *regcache, int regnum,
gdb_byte *regs, size_t offset) gdb_byte *regs, size_t offset, int regsize)
{ {
if (regnum != -1 && offset != -1) if (regnum != -1 && offset != -1)
regcache_raw_collect (regcache, regnum, regs + offset); {
if (regsize > 4)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int gdb_regsize = register_size (gdbarch, regnum);
if (gdb_regsize < regsize)
{
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
{
memset (regs + offset, 0, regsize - gdb_regsize);
offset += regsize - gdb_regsize;
}
else
memset (regs + offset + regsize - gdb_regsize, 0,
regsize - gdb_regsize);
}
}
regcache_raw_collect (regcache, regnum, regs + offset);
}
}
static int
ppc_greg_offset (struct gdbarch *gdbarch,
struct gdbarch_tdep *tdep,
const struct ppc_reg_offsets *offsets,
int regnum,
int *regsize)
{
*regsize = offsets->gpr_size;
if (regnum >= tdep->ppc_gp0_regnum
&& regnum < tdep->ppc_gp0_regnum + ppc_num_gprs)
return (offsets->r0_offset
+ (regnum - tdep->ppc_gp0_regnum) * offsets->gpr_size);
if (regnum == gdbarch_pc_regnum (gdbarch))
return offsets->pc_offset;
if (regnum == tdep->ppc_ps_regnum)
return offsets->ps_offset;
if (regnum == tdep->ppc_lr_regnum)
return offsets->lr_offset;
if (regnum == tdep->ppc_ctr_regnum)
return offsets->ctr_offset;
*regsize = offsets->xr_size;
if (regnum == tdep->ppc_cr_regnum)
return offsets->cr_offset;
if (regnum == tdep->ppc_xer_regnum)
return offsets->xer_offset;
if (regnum == tdep->ppc_mq_regnum)
return offsets->mq_offset;
return -1;
}
static int
ppc_fpreg_offset (struct gdbarch_tdep *tdep,
const struct ppc_reg_offsets *offsets,
int regnum)
{
if (regnum >= tdep->ppc_fp0_regnum
&& regnum < tdep->ppc_fp0_regnum + ppc_num_fprs)
return offsets->f0_offset + (regnum - tdep->ppc_fp0_regnum) * 8;
if (regnum == tdep->ppc_fpscr_regnum)
return offsets->fpscr_offset;
return -1;
} }
/* Supply register REGNUM in the general-purpose register set REGSET /* Supply register REGNUM in the general-purpose register set REGSET
@ -330,36 +417,37 @@ ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
const struct ppc_reg_offsets *offsets = regset->descr; const struct ppc_reg_offsets *offsets = regset->descr;
size_t offset; size_t offset;
int i; int regsize;
for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset; if (regnum == -1)
i < tdep->ppc_gp0_regnum + ppc_num_gprs;
i++, offset += 4)
{ {
if (regnum == -1 || regnum == i) int i;
ppc_supply_reg (regcache, i, gregs, offset); int gpr_size = offsets->gpr_size;
for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
i < tdep->ppc_gp0_regnum + ppc_num_gprs;
i++, offset += gpr_size)
ppc_supply_reg (regcache, i, gregs, offset, gpr_size);
ppc_supply_reg (regcache, gdbarch_pc_regnum (gdbarch),
gregs, offsets->pc_offset, gpr_size);
ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset, gpr_size);
ppc_supply_reg (regcache, tdep->ppc_lr_regnum,
gregs, offsets->lr_offset, gpr_size);
ppc_supply_reg (regcache, tdep->ppc_ctr_regnum,
gregs, offsets->ctr_offset, gpr_size);
ppc_supply_reg (regcache, tdep->ppc_cr_regnum,
gregs, offsets->cr_offset, offsets->xr_size);
ppc_supply_reg (regcache, tdep->ppc_xer_regnum,
gregs, offsets->xer_offset, offsets->xr_size);
ppc_supply_reg (regcache, tdep->ppc_mq_regnum,
gregs, offsets->mq_offset, offsets->xr_size);
return;
} }
if (regnum == -1 || regnum == gdbarch_pc_regnum (current_gdbarch)) offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
ppc_supply_reg (regcache, gdbarch_pc_regnum (current_gdbarch), ppc_supply_reg (regcache, regnum, gregs, offset, regsize);
gregs, offsets->pc_offset);
if (regnum == -1 || regnum == tdep->ppc_ps_regnum)
ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset);
if (regnum == -1 || regnum == tdep->ppc_cr_regnum)
ppc_supply_reg (regcache, tdep->ppc_cr_regnum,
gregs, offsets->cr_offset);
if (regnum == -1 || regnum == tdep->ppc_lr_regnum)
ppc_supply_reg (regcache, tdep->ppc_lr_regnum,
gregs, offsets->lr_offset);
if (regnum == -1 || regnum == tdep->ppc_ctr_regnum)
ppc_supply_reg (regcache, tdep->ppc_ctr_regnum,
gregs, offsets->ctr_offset);
if (regnum == -1 || regnum == tdep->ppc_xer_regnum)
ppc_supply_reg (regcache, tdep->ppc_xer_regnum,
gregs, offsets->cr_offset);
if (regnum == -1 || regnum == tdep->ppc_mq_regnum)
ppc_supply_reg (regcache, tdep->ppc_mq_regnum, gregs, offsets->mq_offset);
} }
/* Supply register REGNUM in the floating-point register set REGSET /* Supply register REGNUM in the floating-point register set REGSET
@ -371,29 +459,36 @@ ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
int regnum, const void *fpregs, size_t len) int regnum, const void *fpregs, size_t len)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep;
const struct ppc_reg_offsets *offsets = regset->descr; const struct ppc_reg_offsets *offsets;
size_t offset; size_t offset;
int i;
gdb_assert (ppc_floating_point_unit_p (gdbarch)); if (!ppc_floating_point_unit_p (gdbarch))
return;
offset = offsets->f0_offset; tdep = gdbarch_tdep (gdbarch);
for (i = tdep->ppc_fp0_regnum; offsets = regset->descr;
i < tdep->ppc_fp0_regnum + ppc_num_fprs; if (regnum == -1)
i++, offset += 8)
{ {
if (regnum == -1 || regnum == i) int i;
ppc_supply_reg (regcache, i, fpregs, offset);
for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
i < tdep->ppc_fp0_regnum + ppc_num_fprs;
i++, offset += 8)
ppc_supply_reg (regcache, i, fpregs, offset, 8);
ppc_supply_reg (regcache, tdep->ppc_fpscr_regnum,
fpregs, offsets->fpscr_offset, offsets->fpscr_size);
return;
} }
if (regnum == -1 || regnum == tdep->ppc_fpscr_regnum) offset = ppc_fpreg_offset (tdep, offsets, regnum);
ppc_supply_reg (regcache, tdep->ppc_fpscr_regnum, ppc_supply_reg (regcache, regnum, fpregs, offset,
fpregs, offsets->fpscr_offset); regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
} }
/* Collect register REGNUM in the general-purpose register set /* Collect register REGNUM in the general-purpose register set
REGSET. from register cache REGCACHE into the buffer specified by REGSET from register cache REGCACHE into the buffer specified by
GREGS and LEN. If REGNUM is -1, do this for all registers in GREGS and LEN. If REGNUM is -1, do this for all registers in
REGSET. */ REGSET. */
@ -406,42 +501,41 @@ ppc_collect_gregset (const struct regset *regset,
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
const struct ppc_reg_offsets *offsets = regset->descr; const struct ppc_reg_offsets *offsets = regset->descr;
size_t offset; size_t offset;
int i; int regsize;
offset = offsets->r0_offset; if (regnum == -1)
for (i = tdep->ppc_gp0_regnum;
i < tdep->ppc_gp0_regnum + ppc_num_gprs;
i++, offset += 4)
{ {
if (regnum == -1 || regnum == i) int i;
ppc_collect_reg (regcache, i, gregs, offset); int gpr_size = offsets->gpr_size;
for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
i < tdep->ppc_gp0_regnum + ppc_num_gprs;
i++, offset += gpr_size)
ppc_collect_reg (regcache, i, gregs, offset, gpr_size);
ppc_collect_reg (regcache, gdbarch_pc_regnum (gdbarch),
gregs, offsets->pc_offset, gpr_size);
ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset, gpr_size);
ppc_collect_reg (regcache, tdep->ppc_lr_regnum,
gregs, offsets->lr_offset, gpr_size);
ppc_collect_reg (regcache, tdep->ppc_ctr_regnum,
gregs, offsets->ctr_offset, gpr_size);
ppc_collect_reg (regcache, tdep->ppc_cr_regnum,
gregs, offsets->cr_offset, offsets->xr_size);
ppc_collect_reg (regcache, tdep->ppc_xer_regnum,
gregs, offsets->xer_offset, offsets->xr_size);
ppc_collect_reg (regcache, tdep->ppc_mq_regnum,
gregs, offsets->mq_offset, offsets->xr_size);
return;
} }
if (regnum == -1 || regnum == gdbarch_pc_regnum (current_gdbarch)) offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
ppc_collect_reg (regcache, gdbarch_pc_regnum (current_gdbarch), ppc_collect_reg (regcache, regnum, gregs, offset, regsize);
gregs, offsets->pc_offset);
if (regnum == -1 || regnum == tdep->ppc_ps_regnum)
ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset);
if (regnum == -1 || regnum == tdep->ppc_cr_regnum)
ppc_collect_reg (regcache, tdep->ppc_cr_regnum,
gregs, offsets->cr_offset);
if (regnum == -1 || regnum == tdep->ppc_lr_regnum)
ppc_collect_reg (regcache, tdep->ppc_lr_regnum,
gregs, offsets->lr_offset);
if (regnum == -1 || regnum == tdep->ppc_ctr_regnum)
ppc_collect_reg (regcache, tdep->ppc_ctr_regnum,
gregs, offsets->ctr_offset);
if (regnum == -1 || regnum == tdep->ppc_xer_regnum)
ppc_collect_reg (regcache, tdep->ppc_xer_regnum,
gregs, offsets->xer_offset);
if (regnum == -1 || regnum == tdep->ppc_mq_regnum)
ppc_collect_reg (regcache, tdep->ppc_mq_regnum,
gregs, offsets->mq_offset);
} }
/* Collect register REGNUM in the floating-point register set /* Collect register REGNUM in the floating-point register set
REGSET. from register cache REGCACHE into the buffer specified by REGSET from register cache REGCACHE into the buffer specified by
FPREGS and LEN. If REGNUM is -1, do this for all registers in FPREGS and LEN. If REGNUM is -1, do this for all registers in
REGSET. */ REGSET. */
@ -451,25 +545,32 @@ ppc_collect_fpregset (const struct regset *regset,
int regnum, void *fpregs, size_t len) int regnum, void *fpregs, size_t len)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep;
const struct ppc_reg_offsets *offsets = regset->descr; const struct ppc_reg_offsets *offsets;
size_t offset; size_t offset;
int i;
gdb_assert (ppc_floating_point_unit_p (gdbarch)); if (!ppc_floating_point_unit_p (gdbarch))
return;
offset = offsets->f0_offset; tdep = gdbarch_tdep (gdbarch);
for (i = tdep->ppc_fp0_regnum; offsets = regset->descr;
i <= tdep->ppc_fp0_regnum + ppc_num_fprs; if (regnum == -1)
i++, offset += 8)
{ {
if (regnum == -1 || regnum == i) int i;
ppc_collect_reg (regcache, i, fpregs, offset);
for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
i < tdep->ppc_fp0_regnum + ppc_num_fprs;
i++, offset += 8)
ppc_collect_reg (regcache, i, fpregs, offset, 8);
ppc_collect_reg (regcache, tdep->ppc_fpscr_regnum,
fpregs, offsets->fpscr_offset, offsets->fpscr_size);
return;
} }
if (regnum == -1 || regnum == tdep->ppc_fpscr_regnum) offset = ppc_fpreg_offset (tdep, offsets, regnum);
ppc_collect_reg (regcache, tdep->ppc_fpscr_regnum, ppc_collect_reg (regcache, regnum, fpregs, offset,
fpregs, offsets->fpscr_offset); regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
} }