OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* config/rs6000/tm-rs6000.h (FP0_REGNUM): Document that this

Browse Source 
should no longer be used in code specific to the RS6000 and its
derivatives.
* ppc-tdep.h (struct gdbarch_tdep): Add 'ppc_fp0_regnum' member.
* rs6000-tdep.c (rs6000_gdbarch_init): Initialize
tdep->ppc_fp0_regnum.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_dwarf2_stab_reg_to_regnum, rs6000_store_return_value)
(rs6000_frame_cache): Use tdep->ppc_fp0_regnum instead of
FP0_REGNUM.
* aix-thread.c (supply_fprs, fetch_regs_kernel_thread)
(fill_gprs64, fill_gprs32, fill_fprs, store_regs_kernel_thread):
Same.
* ppc-bdm.c (bdm_ppc_fetch_registers, bdm_ppc_fetch_registers,
bdm_ppc_store_registers): Same.
* ppc-linux-nat.c (ppc_register_u_addr, fetch_register)
(store_register, fill_fpregset): Same.
* ppc-linux-tdep.c (ppc_linux_sigtramp_cache)
(ppc_linux_supply_fpregset): Same.
* ppcnbsd-nat.c (getfpregs_supplies): Same.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg):
Same.
* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call,
do_ppc_sysv_return_value, ppc64_sysv_abi_push_dummy_call,
ppc64_sysv_abi_return_value): Same.
* rs6000-nat.c (regmap, fetch_inferior_registers)
(store_inferior_registers, fetch_core_registers): Same.
This commit is contained in:
Jim Blandy 2004-05-05 01:46:55 +00:00
parent e792b4ce88
commit 366f009f23
12 changed files with 146 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
gdb/ChangeLog
View File

@ -1,3 +1,34 @@
2004-05-04 Jim Blandy <jimb@redhat.com>
* config/rs6000/tm-rs6000.h (FP0_REGNUM): Document that this
should no longer be used in code specific to the RS6000 and its
derivatives.
* ppc-tdep.h (struct gdbarch_tdep): Add 'ppc_fp0_regnum' member.
* rs6000-tdep.c (rs6000_gdbarch_init): Initialize
tdep->ppc_fp0_regnum.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_dwarf2_stab_reg_to_regnum, rs6000_store_return_value)
(rs6000_frame_cache): Use tdep->ppc_fp0_regnum instead of
FP0_REGNUM.
* aix-thread.c (supply_fprs, fetch_regs_kernel_thread)
(fill_gprs64, fill_gprs32, fill_fprs, store_regs_kernel_thread):
Same.
* ppc-bdm.c (bdm_ppc_fetch_registers, bdm_ppc_fetch_registers,
bdm_ppc_store_registers): Same.
* ppc-linux-nat.c (ppc_register_u_addr, fetch_register)
(store_register, fill_fpregset): Same.
* ppc-linux-tdep.c (ppc_linux_sigtramp_cache)
(ppc_linux_supply_fpregset): Same.
* ppcnbsd-nat.c (getfpregs_supplies): Same.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg):
Same.
* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call,
do_ppc_sysv_return_value, ppc64_sysv_abi_push_dummy_call,
ppc64_sysv_abi_return_value): Same.
* rs6000-nat.c (regmap, fetch_inferior_registers)
(store_inferior_registers, fetch_core_registers): Same.
2004-05-01 Mark Kettenis <kettenis@gnu.org> 2004-05-01 Mark Kettenis <kettenis@gnu.org>
* m68knbsd-nat.c: Remove file. * m68knbsd-nat.c: Remove file.

28
gdb/aix-thread.c
View File

@ -1020,10 +1020,11 @@ supply_reg32 (int regno, uint32_t val)
static void static void
supply_fprs (double *vals) supply_fprs (double *vals)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno; int regno;
for (regno = 0; regno < 32; regno++) for (regno = 0; regno < 32; regno++)
supply_register (regno + FP0_REGNUM, (char *) (vals + regno)); supply_register (regno + tdep->ppc_fp0_regnum, (char *) (vals + regno));
} }
/* Predicate to test whether given register number is a "special" register. */ /* Predicate to test whether given register number is a "special" register. */
@ -1142,6 +1143,7 @@ fetch_regs_user_thread (pthdb_pthread_t pdtid)
static void static void
fetch_regs_kernel_thread (int regno, pthdb_tid_t tid) fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
uint64_t gprs64[32]; uint64_t gprs64[32];
uint32_t gprs32[32]; uint32_t gprs32[32];
double fprs[32]; double fprs[32];
@ -1155,7 +1157,7 @@ fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
(long) tid, regno, arch64); (long) tid, regno, arch64);
/* General-purpose registers. */ /* General-purpose registers. */
if (regno == -1 || regno < FP0_REGNUM) if (regno == -1 || regno < tdep->ppc_fp0_regnum)
{ {
if (arch64) if (arch64)
{ {
@ -1176,8 +1178,8 @@ fetch_regs_kernel_thread (int regno, pthdb_tid_t tid)
/* Floating-point registers. */ /* Floating-point registers. */
if (regno == -1 if (regno == -1
|| (regno >= FP0_REGNUM || (regno >= tdep->ppc_fp0_regnum
&& regno < FP0_REGNUM + ppc_num_fprs)) && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))
{ {
if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL)) if (!ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL))
memset (fprs, 0, sizeof (fprs)); memset (fprs, 0, sizeof (fprs));
@ -1241,9 +1243,10 @@ aix_thread_fetch_registers (int regno)
static void static void
fill_gprs64 (uint64_t *vals) fill_gprs64 (uint64_t *vals)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno; int regno;
for (regno = 0; regno < FP0_REGNUM; regno++) for (regno = 0; regno < tdep->ppc_fp0_regnum; regno++)
if (register_cached (regno)) if (register_cached (regno))
regcache_collect (regno, vals + regno); regcache_collect (regno, vals + regno);
} }
@ -1251,9 +1254,10 @@ fill_gprs64 (uint64_t *vals)
static void static void
fill_gprs32 (uint32_t *vals) fill_gprs32 (uint32_t *vals)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno; int regno;
for (regno = 0; regno < FP0_REGNUM; regno++) for (regno = 0; regno < tdep->ppc_fp0_regnum; regno++)
if (register_cached (regno)) if (register_cached (regno))
regcache_collect (regno, vals + regno); regcache_collect (regno, vals + regno);
} }
@ -1262,9 +1266,12 @@ fill_gprs32 (uint32_t *vals)
static void static void
fill_fprs (double *vals) fill_fprs (double *vals)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int regno; int regno;
for (regno = FP0_REGNUM; regno < FP0_REGNUM + ppc_num_fprs; regno++) for (regno = tdep->ppc_fp0_regnum;
regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
regno++)
if (register_cached (regno)) if (register_cached (regno))
regcache_collect (regno, vals + regno); regcache_collect (regno, vals + regno);
} }
@ -1434,6 +1441,7 @@ store_regs_user_thread (pthdb_pthread_t pdtid)
static void static void
store_regs_kernel_thread (int regno, pthdb_tid_t tid) store_regs_kernel_thread (int regno, pthdb_tid_t tid)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
uint64_t gprs64[32]; uint64_t gprs64[32];
uint32_t gprs32[32]; uint32_t gprs32[32];
double fprs[32]; double fprs[32];
@ -1448,7 +1456,7 @@ store_regs_kernel_thread (int regno, pthdb_tid_t tid)
(long) tid, regno); (long) tid, regno);
/* General-purpose registers. */ /* General-purpose registers. */
if (regno == -1 || regno < FP0_REGNUM) if (regno == -1 || regno < tdep->ppc_fp0_regnum)
{ {
if (arch64) if (arch64)
{ {
@ -1469,8 +1477,8 @@ store_regs_kernel_thread (int regno, pthdb_tid_t tid)
/* Floating-point registers. */ /* Floating-point registers. */
if (regno == -1 if (regno == -1
|| (regno >= FP0_REGNUM || (regno >= tdep->ppc_fp0_regnum
&& regno < FP0_REGNUM + ppc_num_fprs)) && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))
{ {
/* Pre-fetch: some regs may not be in the cache. */ /* Pre-fetch: some regs may not be in the cache. */
ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL); ptrace32 (PTT_READ_FPRS, tid, (int *) fprs, 0, NULL);

4
gdb/config/rs6000/tm-rs6000.h
View File

@ -71,6 +71,10 @@ extern void aix_process_linenos (void);
to be actual register numbers as far as the user is concerned to be actual register numbers as far as the user is concerned
but do serve to get the desired values when passed to read_register. */ but do serve to get the desired values when passed to read_register. */
/* Don't use this in code specific to the RS6000 and its descendants;
use tdep->ppc_fp0_regnum instead. FP0_REGNUM will be deprecated
soon, but we still need to define it here for the uses in
architecture-independent code. */
#define FP0_REGNUM 32 /* Floating point register 0 */ #define FP0_REGNUM 32 /* Floating point register 0 */
/* Notice when a new child process is started. */ /* Notice when a new child process is started. */

19
gdb/ppc-bdm.c
View File

@ -153,6 +153,7 @@ static int bdm_regmap[] =
static void static void
bdm_ppc_fetch_registers (int regno) bdm_ppc_fetch_registers (int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i; int i;
unsigned char *regs, *beginregs, *endregs, *almostregs; unsigned char *regs, *beginregs, *endregs, *almostregs;
unsigned char midregs[32]; unsigned char midregs[32];
@ -202,8 +203,8 @@ bdm_ppc_fetch_registers (int regno)
/* if asking for an invalid register */ /* if asking for an invalid register */
if ((first_regno == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum) if ((first_regno == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
|| (first_regno == gdbarch_tdep (current_gdbarch)->ppc_fpscr_regnum) || (first_regno == gdbarch_tdep (current_gdbarch)->ppc_fpscr_regnum)
|| ((first_regno >= FP0_REGNUM) || ((first_regno >= tdep->ppc_fp0_regnum)
&& (first_regno < FP0_REGNUM + ppc_num_fprs))) && (first_regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{ {
/* printf("invalid reg request!\n"); */ /* printf("invalid reg request!\n"); */
supply_register (first_regno, NULL); supply_register (first_regno, NULL);
@ -220,10 +221,12 @@ bdm_ppc_fetch_registers (int regno)
{ {
/* printf("Asking for registers %d to %d\n", first_regno, last_regno); */ /* printf("Asking for registers %d to %d\n", first_regno, last_regno); */
beginregs = ocd_read_bdm_registers (first_bdm_regno, beginregs = ocd_read_bdm_registers (first_bdm_regno,
FP0_REGNUM - 1, &beginreglen); tdep->ppc_fp0_regnum - 1,
endregs = (strcat (midregs, &beginreglen);
ocd_read_bdm_registers (FP0_REGNUM + ppc_num_fprs, endregs
last_bdm_regno - 1, &endreglen))); = (strcat (midregs,
ocd_read_bdm_registers (tdep->ppc_fp0_regnum + ppc_num_fprs,
last_bdm_regno - 1, &endreglen)));
almostregs = (strcat (beginregs, endregs)); almostregs = (strcat (beginregs, endregs));
regs = (strcat (almostregs, mqreg)); regs = (strcat (almostregs, mqreg));
reglen = beginreglen + 32 + endreglen + 1; reglen = beginreglen + 32 + endreglen + 1;
@ -259,6 +262,7 @@ bdm_ppc_fetch_registers (int regno)
static void static void
bdm_ppc_store_registers (int regno) bdm_ppc_store_registers (int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i; int i;
int first_regno, last_regno; int first_regno, last_regno;
int first_bdm_regno, last_bdm_regno; int first_bdm_regno, last_bdm_regno;
@ -293,7 +297,8 @@ bdm_ppc_store_registers (int regno)
/* (need to avoid FP regs and MQ reg) */ /* (need to avoid FP regs and MQ reg) */
if ((i != gdbarch_tdep (current_gdbarch)->ppc_mq_regnum) if ((i != gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
&& (i != gdbarch_tdep (current_gdbarch)->ppc_fpscr_regnum) && (i != gdbarch_tdep (current_gdbarch)->ppc_fpscr_regnum)
&& ((i < FP0_REGNUM) || (i >= FP0_REGNUM + ppc_num_fprs))) && ((i < tdep->ppc_fp0_regnum)
|| (i >= tdep->ppc_fp0_regnum + ppc_num_fprs)))
{ {
/* printf("write valid reg %d\n", bdm_regno); */ /* printf("write valid reg %d\n", bdm_regno); */
ocd_write_bdm_registers (bdm_regno, deprecated_registers + DEPRECATED_REGISTER_BYTE (i), 4); ocd_write_bdm_registers (bdm_regno, deprecated_registers + DEPRECATED_REGISTER_BYTE (i), 4);

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

@ -139,8 +139,9 @@ ppc_register_u_addr (int regno)
/* Floating point regs: eight bytes each in both 32- and 64-bit /* Floating point regs: eight bytes each in both 32- and 64-bit
ptrace interfaces. Thus, two slots each in 32-bit interface, one ptrace interfaces. Thus, two slots each in 32-bit interface, one
slot each in 64-bit interface. */ slot each in 64-bit interface. */
if (regno >= FP0_REGNUM && regno < FP0_REGNUM + ppc_num_fprs) if (regno >= tdep->ppc_fp0_regnum
u_addr = (PT_FPR0 * wordsize) + ((regno - FP0_REGNUM) * 8); && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8);
/* UISA special purpose registers: 1 slot each */ /* UISA special purpose registers: 1 slot each */
if (regno == PC_REGNUM) if (regno == PC_REGNUM)
@ -202,6 +203,7 @@ fetch_altivec_register (int tid, int regno)
static void static void
fetch_register (int tid, int regno) fetch_register (int tid, int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* This isn't really an address. But ptrace thinks of it as one. */ /* This isn't really an address. But ptrace thinks of it as one. */
char mess[128]; /* For messages */ char mess[128]; /* For messages */
int i; int i;
@ -251,7 +253,8 @@ fetch_register (int tid, int regno)
/* Now supply the register. Be careful to map between ptrace's and /* Now supply the register. Be careful to map between ptrace's and
the current_regcache's idea of the current wordsize. */ the current_regcache's idea of the current wordsize. */
if ((regno >= FP0_REGNUM && regno < FP0_REGNUM +32) if ((regno >= tdep->ppc_fp0_regnum
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
|| gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE) || gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
/* FPs are always 64 bits. Little endian values are always found /* FPs are always 64 bits. Little endian values are always found
at the left-hand end of the register. */ at the left-hand end of the register. */
@ -376,6 +379,7 @@ store_altivec_register (int tid, int regno)
static void static void
store_register (int tid, int regno) store_register (int tid, int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* This isn't really an address. But ptrace thinks of it as one. */ /* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr = ppc_register_u_addr (regno); CORE_ADDR regaddr = ppc_register_u_addr (regno);
char mess[128]; /* For messages */ char mess[128]; /* For messages */
@ -395,7 +399,8 @@ store_register (int tid, int regno)
/* First collect the register value from the regcache. Be careful /* First collect the register value from the regcache. Be careful
to to convert the regcache's wordsize into ptrace's wordsize. */ to to convert the regcache's wordsize into ptrace's wordsize. */
memset (buf, 0, sizeof buf); memset (buf, 0, sizeof buf);
if ((regno >= FP0_REGNUM && regno < FP0_REGNUM + 32) if ((regno >= tdep->ppc_fp0_regnum
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
|| TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE) || TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
/* Floats are always 64-bit. Little endian registers are always /* Floats are always 64-bit. Little endian registers are always
at the left-hand end of the register cache. */ at the left-hand end of the register cache. */
@ -585,8 +590,8 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
{ {
if ((regno == -1) || (regno == FP0_REGNUM + regi)) if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi); regcache_collect (tdep->ppc_fp0_regnum + regi, fpp + 8 * regi);
} }
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum) if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32)); right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));

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

@ -946,7 +946,7 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame, void **this_cache)
/* Floating point registers. */ /* Floating point registers. */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
{ {
int regnum = i + FP0_REGNUM; int regnum = i + tdep->ppc_fp0_regnum;
cache->saved_regs[regnum].addr = fpregs + i * tdep->wordsize; cache->saved_regs[regnum].addr = fpregs + i * tdep->wordsize;
} }
cache->saved_regs[tdep->ppc_fpscr_regnum].addr = fpregs + 32 * tdep->wordsize; cache->saved_regs[tdep->ppc_fpscr_regnum].addr = fpregs + 32 * tdep->wordsize;
@ -1019,7 +1019,9 @@ ppc_linux_supply_fpregset (const struct regset *regset,
const bfd_byte *buf = fpset; const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * 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 /* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */ fpregset. */

44
gdb/ppc-sysv-tdep.c
View File

@ -114,9 +114,10 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
the register's floating-point format. */ the register's floating-point format. */
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype struct type *regtype
= register_type (gdbarch, FP0_REGNUM + freg); = register_type (gdbarch, tdep->ppc_fp0_regnum + freg);
convert_typed_floating (val, type, regval, regtype); convert_typed_floating (val, type, regval, regtype);
regcache_cooked_write (regcache, FP0_REGNUM + freg, regcache_cooked_write (regcache,
tdep->ppc_fp0_regnum + freg,
regval); regval);
} }
freg++; freg++;
@ -338,8 +339,9 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
/* Floats and doubles stored in "f1". Convert the value to /* Floats and doubles stored in "f1". Convert the value to
the required type. */ the required type. */
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype = register_type (gdbarch, FP0_REGNUM + 1); struct type *regtype = register_type (gdbarch,
regcache_cooked_read (regcache, FP0_REGNUM + 1, regval); tdep->ppc_fp0_regnum + 1);
regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
convert_typed_floating (regval, regtype, readbuf, type); convert_typed_floating (regval, regtype, readbuf, type);
} }
if (writebuf) if (writebuf)
@ -347,9 +349,9 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
/* Floats and doubles stored in "f1". Convert the value to /* Floats and doubles stored in "f1". Convert the value to
the register's "double" type. */ the register's "double" type. */
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype = register_type (gdbarch, FP0_REGNUM); struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
convert_typed_floating (writebuf, type, regval, regtype); convert_typed_floating (writebuf, type, regval, regtype);
regcache_cooked_write (regcache, FP0_REGNUM + 1, regval); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
} }
return RETURN_VALUE_REGISTER_CONVENTION; return RETURN_VALUE_REGISTER_CONVENTION;
} }
@ -643,10 +645,11 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
&& freg <= 13) && freg <= 13)
{ {
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype = register_type (gdbarch, struct type *regtype
FP0_REGNUM); = register_type (gdbarch, tdep->ppc_fp0_regnum);
convert_typed_floating (val, type, regval, regtype); convert_typed_floating (val, type, regval, regtype);
regcache_cooked_write (regcache, FP0_REGNUM + freg, regcache_cooked_write (regcache,
tdep->ppc_fp0_regnum + freg,
regval); regval);
} }
if (greg <= 10) if (greg <= 10)
@ -851,15 +854,15 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8) if (TYPE_CODE (valtype) == TYPE_CODE_FLT && TYPE_LENGTH (valtype) <= 8)
{ {
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype = register_type (gdbarch, FP0_REGNUM); struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
if (writebuf != NULL) if (writebuf != NULL)
{ {
convert_typed_floating (writebuf, valtype, regval, regtype); convert_typed_floating (writebuf, valtype, regval, regtype);
regcache_cooked_write (regcache, FP0_REGNUM + 1, regval); regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, regval);
} }
if (readbuf != NULL) if (readbuf != NULL)
{ {
regcache_cooked_read (regcache, FP0_REGNUM + 1, regval); regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, regval);
convert_typed_floating (regval, regtype, readbuf, valtype); convert_typed_floating (regval, regtype, readbuf, valtype);
} }
return RETURN_VALUE_REGISTER_CONVENTION; return RETURN_VALUE_REGISTER_CONVENTION;
@ -921,10 +924,10 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++) for (i = 0; i < TYPE_LENGTH (valtype) / 8; i++)
{ {
if (writebuf != NULL) if (writebuf != NULL)
regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
(const bfd_byte *) writebuf + i * 8); (const bfd_byte *) writebuf + i * 8);
if (readbuf != NULL) if (readbuf != NULL)
regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
(bfd_byte *) readbuf + i * 8); (bfd_byte *) readbuf + i * 8);
} }
} }
@ -941,18 +944,21 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
{ {
char regval[MAX_REGISTER_SIZE]; char regval[MAX_REGISTER_SIZE];
struct type *regtype = struct type *regtype =
register_type (current_gdbarch, FP0_REGNUM); register_type (current_gdbarch, tdep->ppc_fp0_regnum);
if (writebuf != NULL) if (writebuf != NULL)
{ {
convert_typed_floating ((const bfd_byte *) writebuf + convert_typed_floating ((const bfd_byte *) writebuf +
i * (TYPE_LENGTH (valtype) / 2), i * (TYPE_LENGTH (valtype) / 2),
valtype, regval, regtype); valtype, regval, regtype);
regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, regcache_cooked_write (regcache,
tdep->ppc_fp0_regnum + 1 + i,
regval); regval);
} }
if (readbuf != NULL) if (readbuf != NULL)
{ {
regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regval); regcache_cooked_read (regcache,
tdep->ppc_fp0_regnum + 1 + i,
regval);
convert_typed_floating (regval, regtype, convert_typed_floating (regval, regtype,
(bfd_byte *) readbuf + (bfd_byte *) readbuf +
i * (TYPE_LENGTH (valtype) / 2), i * (TYPE_LENGTH (valtype) / 2),
@ -971,10 +977,10 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
{ {
if (writebuf != NULL) if (writebuf != NULL)
regcache_cooked_write (regcache, FP0_REGNUM + 1 + i, regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1 + i,
(const bfd_byte *) writebuf + i * 8); (const bfd_byte *) writebuf + i * 8);
if (readbuf != NULL) if (readbuf != NULL)
regcache_cooked_read (regcache, FP0_REGNUM + 1 + i, regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1 + i,
(bfd_byte *) readbuf + i * 8); (bfd_byte *) readbuf + i * 8);
} }
} }

1
gdb/ppc-tdep.h
View File

@ -150,6 +150,7 @@ struct gdbarch_tdep
int ppc_lr_regnum; /* Link register */ int ppc_lr_regnum; /* Link register */
int ppc_ctr_regnum; /* Count register */ int ppc_ctr_regnum; /* Count register */
int ppc_xer_regnum; /* Integer exception register */ int ppc_xer_regnum; /* Integer exception register */
int ppc_fp0_regnum; /* floating-point register 0 */
int ppc_fpscr_regnum; /* Floating point status and condition int ppc_fpscr_regnum; /* Floating point status and condition
register */ register */
int ppc_mq_regnum; /* Multiply/Divide extension register */ int ppc_mq_regnum; /* Multiply/Divide extension register */

3
gdb/ppcnbsd-nat.c
View File

@ -49,7 +49,8 @@ getfpregs_supplies (int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
return ((regno >= FP0_REGNUM && regno <= FP0_REGNUM + 31) return ((regno >= tdep->ppc_fp0_regnum
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
|| regno == tdep->ppc_fpscr_regnum); || regno == tdep->ppc_fpscr_regnum);
} }

14
gdb/ppcnbsd-tdep.c
View File

@ -111,10 +111,11 @@ ppcnbsd_supply_fpreg (char *fpregs, int regno)
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i; int i;
for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++) for (i = 0; i < ppc_num_fprs; i++)
{ {
if (regno == i || regno == -1) if (regno == tdep->ppc_fp0_regnum + i || regno == -1)
supply_register (i, fpregs + FPREG_FPR_OFFSET (i - FP0_REGNUM)); supply_register (tdep->ppc_fp0_regnum + i,
fpregs + FPREG_FPR_OFFSET (i));
} }
if (regno == tdep->ppc_fpscr_regnum || regno == -1) if (regno == tdep->ppc_fpscr_regnum || regno == -1)
@ -127,10 +128,11 @@ ppcnbsd_fill_fpreg (char *fpregs, int regno)
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i; int i;
for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++) for (i = 0; i < ppc_num_fprs; i++)
{ {
if (regno == i || regno == -1) if (regno == tdep->ppc_fp0_regnum + i || regno == -1)
regcache_collect (i, fpregs + FPREG_FPR_OFFSET (i - FP0_REGNUM)); regcache_collect (tdep->ppc_fp0_regnum + i,
fpregs + FPREG_FPR_OFFSET (i));
} }
if (regno == tdep->ppc_fpscr_regnum || regno == -1) if (regno == tdep->ppc_fpscr_regnum || regno == -1)

19
gdb/rs6000-nat.c
View File

@ -159,10 +159,11 @@ regmap (int regno, int *isfloat)
if (tdep->ppc_gp0_regnum <= regno if (tdep->ppc_gp0_regnum <= regno
&& regno < tdep->ppc_gp0_regnum + ppc_num_gprs) && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
return regno; return regno;
else if (FP0_REGNUM <= regno && regno < FP0_REGNUM + ppc_num_fprs) else if (tdep->ppc_fp0_regnum <= regno
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
{ {
*isfloat = 1; *isfloat = 1;
return regno - FP0_REGNUM + FPR0; return regno - tdep->ppc_fp0_regnum + FPR0;
} }
else if (regno == PC_REGNUM) else if (regno == PC_REGNUM)
return IAR; return IAR;
@ -358,8 +359,8 @@ fetch_inferior_registers (int regno)
} }
/* Read general purpose floating point registers. */ /* Read general purpose floating point registers. */
for (regno = FP0_REGNUM; regno < FP0_REGNUM + ppc_num_fprs; regno++) for (regno = 0; regno < ppc_num_fprs; regno++)
fetch_register (regno); fetch_register (tdep->ppc_fp0_regnum + regno);
/* Read special registers. */ /* Read special registers. */
fetch_register (PC_REGNUM); fetch_register (PC_REGNUM);
@ -397,8 +398,8 @@ store_inferior_registers (int regno)
} }
/* Write floating point registers. */ /* Write floating point registers. */
for (regno = FP0_REGNUM; regno < FP0_REGNUM + ppc_num_fprs; regno ++) for (regno = 0; regno < ppc_num_fprs; regno++)
store_register (regno); store_register (tdep->ppc_fp0_regnum + regno);
/* Write special registers. */ /* Write special registers. */
store_register (PC_REGNUM); store_register (PC_REGNUM);
@ -583,7 +584,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
supply_register (regi, (char *) &regs->r64.gpr[regi]); supply_register (regi, (char *) &regs->r64.gpr[regi]);
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
supply_register (FP0_REGNUM + regi, (char *) &regs->r64.fpr[regi]); supply_register (tdep->ppc_fp0_regnum + regi,
(char *) &regs->r64.fpr[regi]);
supply_register (PC_REGNUM, (char *) &regs->r64.iar); supply_register (PC_REGNUM, (char *) &regs->r64.iar);
supply_register (tdep->ppc_ps_regnum, (char *) &regs->r64.msr); supply_register (tdep->ppc_ps_regnum, (char *) &regs->r64.msr);
@ -599,7 +601,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
supply_register (regi, (char *) &regs->r32.gpr[regi]); supply_register (regi, (char *) &regs->r32.gpr[regi]);
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
supply_register (FP0_REGNUM + regi, (char *) &regs->r32.fpr[regi]); supply_register (tdep->ppc_fp0_regnum + regi,
(char *) &regs->r32.fpr[regi]);
supply_register (PC_REGNUM, (char *) &regs->r32.iar); supply_register (PC_REGNUM, (char *) &regs->r32.iar);
supply_register (tdep->ppc_ps_regnum, (char *) &regs->r32.msr); supply_register (tdep->ppc_ps_regnum, (char *) &regs->r32.msr);

28
gdb/rs6000-tdep.c
View File

@ -227,7 +227,9 @@ ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
int i; int i;
offset = offsets->f0_offset; offset = offsets->f0_offset;
for (i = FP0_REGNUM; i < FP0_REGNUM + 32; i++, offset += 4) for (i = tdep->ppc_fp0_regnum;
i < tdep->ppc_fp0_regnum + ppc_num_fprs;
i++, offset += 4)
{ {
if (regnum == -1 || regnum == i) if (regnum == -1 || regnum == i)
ppc_supply_reg (regcache, i, fpregs, offset); ppc_supply_reg (regcache, i, fpregs, offset);
@ -300,7 +302,9 @@ ppc_collect_fpregset (const struct regset *regset,
int i; int i;
offset = offsets->f0_offset; offset = offsets->f0_offset;
for (i = FP0_REGNUM; i <= FP0_REGNUM + 32; i++, offset += 4) for (i = tdep->ppc_fp0_regnum;
i <= tdep->ppc_fp0_regnum + ppc_num_fprs;
i++, offset += 4)
{ {
if (regnum == -1 || regnum == i) if (regnum == -1 || regnum == i)
ppc_collect_reg (regcache, regnum, fpregs, offset); ppc_collect_reg (regcache, regnum, fpregs, offset);
@ -1239,7 +1243,8 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
printf_unfiltered ( printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE
(tdep->ppc_fp0_regnum + 1 + f_argno)],
VALUE_CONTENTS (arg), VALUE_CONTENTS (arg),
len); len);
++f_argno; ++f_argno;
@ -1352,7 +1357,9 @@ ran_out_of_registers_for_arguments:
printf_unfiltered ( printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], memcpy (&(deprecated_registers
[DEPRECATED_REGISTER_BYTE
(tdep->ppc_fp0_regnum + 1 + f_argno)]),
VALUE_CONTENTS (arg), VALUE_CONTENTS (arg),
len); len);
++f_argno; ++f_argno;
@ -1417,7 +1424,7 @@ rs6000_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
necessary. */ necessary. */
convert_typed_floating (&regbuf[DEPRECATED_REGISTER_BYTE convert_typed_floating (&regbuf[DEPRECATED_REGISTER_BYTE
(FP0_REGNUM + 1)], (tdep->ppc_fp0_regnum + 1)],
builtin_type_double, builtin_type_double,
valbuf, valbuf,
valtype); valtype);
@ -1720,7 +1727,7 @@ rs6000_dwarf2_stab_reg_to_regnum (int num)
if (0 <= num && num <= 31) if (0 <= num && num <= 31)
return tdep->ppc_gp0_regnum + num; return tdep->ppc_gp0_regnum + num;
else if (32 <= num && num <= 63) else if (32 <= num && num <= 63)
return FP0_REGNUM + (num - 32); return tdep->ppc_fp0_regnum + (num - 32);
else if (1200 <= num && num < 1200 + 32) else if (1200 <= num && num < 1200 + 32)
return tdep->ppc_ev0_regnum + (num - 1200); return tdep->ppc_ev0_regnum + (num - 1200);
else else
@ -1764,8 +1771,10 @@ rs6000_store_return_value (struct type *type, char *valbuf)
Say a double_double_double type could be returned in Say a double_double_double type could be returned in
FPR1/FPR2/FPR3 triple. */ FPR1/FPR2/FPR3 triple. */
deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1), valbuf, deprecated_write_register_bytes
TYPE_LENGTH (type)); (DEPRECATED_REGISTER_BYTE (tdep->ppc_fp0_regnum + 1),
valbuf,
TYPE_LENGTH (type));
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY) else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{ {
if (TYPE_LENGTH (type) == 16 if (TYPE_LENGTH (type) == 16
@ -2438,7 +2447,7 @@ rs6000_frame_cache (struct frame_info *next_frame, void **this_cache)
CORE_ADDR fpr_addr = cache->base + fdata.fpr_offset; CORE_ADDR fpr_addr = cache->base + fdata.fpr_offset;
for (i = fdata.saved_fpr; i < 32; i++) for (i = fdata.saved_fpr; i < 32; i++)
{ {
cache->saved_regs[FP0_REGNUM + i].addr = fpr_addr; cache->saved_regs[tdep->ppc_fp0_regnum + i].addr = fpr_addr;
fpr_addr += 8; fpr_addr += 8;
} }
} }
@ -2713,6 +2722,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
tdep->ppc_mq_regnum = 70; tdep->ppc_mq_regnum = 70;
else else
tdep->ppc_mq_regnum = -1; tdep->ppc_mq_regnum = -1;
tdep->ppc_fp0_regnum = 32;
tdep->ppc_fpscr_regnum = power ? 71 : 70; tdep->ppc_fpscr_regnum = power ? 71 : 70;
set_gdbarch_pc_regnum (gdbarch, 64); set_gdbarch_pc_regnum (gdbarch, 64);