2002-02-21 22:04:46 +00:00
|
|
|
/* PPC GNU/Linux native support.
|
2003-02-07 04:49:34 +00:00
|
|
|
|
|
|
|
Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002,
|
|
|
|
2003 Free Software Foundation, Inc.
|
2000-02-22 01:20:32 +00:00
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
2002-02-18 15:08:40 +00:00
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
Boston, MA 02111-1307, USA. */
|
2000-02-22 01:20:32 +00:00
|
|
|
|
|
|
|
#include "defs.h"
|
2002-12-06 16:59:05 +00:00
|
|
|
#include "gdb_string.h"
|
2000-02-22 01:20:32 +00:00
|
|
|
#include "frame.h"
|
|
|
|
#include "inferior.h"
|
|
|
|
#include "gdbcore.h"
|
2001-03-01 01:39:22 +00:00
|
|
|
#include "regcache.h"
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
#include "gdb_assert.h"
|
2000-02-22 01:20:32 +00:00
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/user.h>
|
|
|
|
#include <sys/ioctl.h>
|
2003-02-07 04:49:34 +00:00
|
|
|
#include "gdb_wait.h"
|
2000-02-22 01:20:32 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/procfs.h>
|
2001-12-20 23:31:27 +00:00
|
|
|
#include <sys/ptrace.h>
|
2000-02-22 01:20:32 +00:00
|
|
|
|
2000-05-26 Michael Snyder <msnyder@seadog.cygnus.com>
* gregset.h: New file. Typedefs for gdb_gregset_t and
gdb_fpregset_t, prototypes for supply_gregset and friends.
* procfs.c: Include gregset.h. Delete local prototypes for
supply_gregset etc., and local typedef gdb_gregset_t etc.
* sol-thread.c: Include gregset.h, delete local prototypes,
add appropriate casts to gdb_gregset_t.
* uw-thread.c, lin-thread.c, core-sol2.c, core-regset.c,
sparc-tdep.c, ptx4-nat.c, ppc-linux-nat.c, mipsv4-nat.c,
m88k-nat.c, m68klinux-nat.c, m68k-tdep.c, irix5-nat.c,
irix4-nat.c, ia64-linux-nat.c, i386v4-nat.c, cxux-nat.c,
arm-linux-nat.c, alpha-nat.c: Include gregset.h.
* config/nm-linux.h: Define GDB_GREGSET_T, GDB_FPREGET_T.
* config/sparc/tm-sun4sol2.h: Ditto.
2000-05-26 23:22:41 +00:00
|
|
|
/* Prototypes for supply_gregset etc. */
|
|
|
|
#include "gregset.h"
|
2001-11-30 02:14:08 +00:00
|
|
|
#include "ppc-tdep.h"
|
2000-05-26 Michael Snyder <msnyder@seadog.cygnus.com>
* gregset.h: New file. Typedefs for gdb_gregset_t and
gdb_fpregset_t, prototypes for supply_gregset and friends.
* procfs.c: Include gregset.h. Delete local prototypes for
supply_gregset etc., and local typedef gdb_gregset_t etc.
* sol-thread.c: Include gregset.h, delete local prototypes,
add appropriate casts to gdb_gregset_t.
* uw-thread.c, lin-thread.c, core-sol2.c, core-regset.c,
sparc-tdep.c, ptx4-nat.c, ppc-linux-nat.c, mipsv4-nat.c,
m88k-nat.c, m68klinux-nat.c, m68k-tdep.c, irix5-nat.c,
irix4-nat.c, ia64-linux-nat.c, i386v4-nat.c, cxux-nat.c,
arm-linux-nat.c, alpha-nat.c: Include gregset.h.
* config/nm-linux.h: Define GDB_GREGSET_T, GDB_FPREGET_T.
* config/sparc/tm-sun4sol2.h: Ditto.
2000-05-26 23:22:41 +00:00
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
#ifndef PT_READ_U
|
|
|
|
#define PT_READ_U PTRACE_PEEKUSR
|
|
|
|
#endif
|
|
|
|
#ifndef PT_WRITE_U
|
|
|
|
#define PT_WRITE_U PTRACE_POKEUSR
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Default the type of the ptrace transfer to int. */
|
|
|
|
#ifndef PTRACE_XFER_TYPE
|
|
|
|
#define PTRACE_XFER_TYPE int
|
|
|
|
#endif
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
/* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a
|
|
|
|
configure time check. Some older glibc's (for instance 2.2.1)
|
|
|
|
don't have a specific powerpc version of ptrace.h, and fall back on
|
|
|
|
a generic one. In such cases, sys/ptrace.h defines
|
|
|
|
PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that
|
|
|
|
ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and
|
|
|
|
PTRACE_SETVRREGS to be. This also makes a configury check pretty
|
|
|
|
much useless. */
|
|
|
|
|
|
|
|
/* These definitions should really come from the glibc header files,
|
|
|
|
but Glibc doesn't know about the vrregs yet. */
|
|
|
|
#ifndef PTRACE_GETVRREGS
|
|
|
|
#define PTRACE_GETVRREGS 18
|
|
|
|
#define PTRACE_SETVRREGS 19
|
|
|
|
#endif
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
|
|
|
|
/* Similarly for the ptrace requests for getting / setting the SPE
|
|
|
|
registers (ev0 -- ev31, acc, and spefscr). See the description of
|
|
|
|
gdb_evrregset_t for details. */
|
|
|
|
#ifndef PTRACE_GETEVRREGS
|
|
|
|
#define PTRACE_GETEVRREGS 20
|
|
|
|
#define PTRACE_SETEVRREGS 21
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
/* This oddity is because the Linux kernel defines elf_vrregset_t as
|
|
|
|
an array of 33 16 bytes long elements. I.e. it leaves out vrsave.
|
|
|
|
However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return
|
|
|
|
the vrsave as an extra 4 bytes at the end. I opted for creating a
|
|
|
|
flat array of chars, so that it is easier to manipulate for gdb.
|
|
|
|
|
|
|
|
There are 32 vector registers 16 bytes longs, plus a VSCR register
|
|
|
|
which is only 4 bytes long, but is fetched as a 16 bytes
|
|
|
|
quantity. Up to here we have the elf_vrregset_t structure.
|
|
|
|
Appended to this there is space for the VRSAVE register: 4 bytes.
|
|
|
|
Even though this vrsave register is not included in the regset
|
|
|
|
typedef, it is handled by the ptrace requests.
|
|
|
|
|
|
|
|
Note that GNU/Linux doesn't support little endian PPC hardware,
|
|
|
|
therefore the offset at which the real value of the VSCR register
|
|
|
|
is located will be always 12 bytes.
|
|
|
|
|
|
|
|
The layout is like this (where x is the actual value of the vscr reg): */
|
|
|
|
|
|
|
|
/* *INDENT-OFF* */
|
|
|
|
/*
|
|
|
|
|.|.|.|.|.....|.|.|.|.||.|.|.|x||.|
|
|
|
|
<-------> <-------><-------><->
|
|
|
|
VR0 VR31 VSCR VRSAVE
|
|
|
|
*/
|
|
|
|
/* *INDENT-ON* */
|
|
|
|
|
|
|
|
#define SIZEOF_VRREGS 33*16+4
|
|
|
|
|
|
|
|
typedef char gdb_vrregset_t[SIZEOF_VRREGS];
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
|
|
|
|
/* On PPC processors that support the the Signal Processing Extension
|
|
|
|
(SPE) APU, the general-purpose registers are 64 bits long.
|
|
|
|
However, the ordinary Linux PTRACE_PEEKUSR / PTRACE_POKEUSR /
|
|
|
|
PT_READ_U / PT_WRITE_U ptrace calls only access the lower half of
|
|
|
|
each register, to allow them to behave the same way they do on
|
|
|
|
non-SPE systems. There's a separate pair of calls,
|
|
|
|
PTRACE_GETEVRREGS / PTRACE_SETEVRREGS, that read and write the top
|
|
|
|
halves of all the general-purpose registers at once, along with
|
|
|
|
some SPE-specific registers.
|
|
|
|
|
|
|
|
GDB itself continues to claim the general-purpose registers are 32
|
|
|
|
bits long; the full 64-bit registers are called 'ev0' -- 'ev31'.
|
|
|
|
The ev registers are raw registers, and the GPR's are pseudo-
|
|
|
|
registers mapped onto their lower halves. This means that reading
|
|
|
|
and writing ev registers involves a mix of regset-at-once
|
|
|
|
PTRACE_{GET,SET}EVRREGS calls and register-at-a-time
|
|
|
|
PTRACE_{PEEK,POKE}USR calls.
|
|
|
|
|
|
|
|
This is the structure filled in by PTRACE_GETEVRREGS and written to
|
|
|
|
the inferior's registers by PTRACE_SETEVRREGS. */
|
|
|
|
struct gdb_evrregset_t
|
|
|
|
{
|
|
|
|
unsigned long evr[32];
|
|
|
|
unsigned long long acc;
|
|
|
|
unsigned long spefscr;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Non-zero if our kernel may support the PTRACE_GETVRREGS and
|
|
|
|
PTRACE_SETVRREGS requests, for reading and writing the Altivec
|
|
|
|
registers. Zero if we've tried one of them and gotten an
|
|
|
|
error. */
|
2002-02-21 22:04:46 +00:00
|
|
|
int have_ptrace_getvrregs = 1;
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
|
|
|
|
/* Non-zero if our kernel may support the PTRACE_GETEVRREGS and
|
|
|
|
PTRACE_SETEVRREGS requests, for reading and writing the SPE
|
|
|
|
registers. Zero if we've tried one of them and gotten an
|
|
|
|
error. */
|
|
|
|
int have_ptrace_getsetevrregs = 1;
|
|
|
|
|
|
|
|
|
2000-02-22 01:20:32 +00:00
|
|
|
int
|
2000-07-30 01:48:28 +00:00
|
|
|
kernel_u_size (void)
|
2000-02-22 01:20:32 +00:00
|
|
|
{
|
|
|
|
return (sizeof (struct user));
|
|
|
|
}
|
|
|
|
|
2001-11-30 02:14:08 +00:00
|
|
|
/* *INDENT-OFF* */
|
|
|
|
/* registers layout, as presented by the ptrace interface:
|
|
|
|
PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
|
|
|
|
PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_R13, PT_R14, PT_R15,
|
|
|
|
PT_R16, PT_R17, PT_R18, PT_R19, PT_R20, PT_R21, PT_R22, PT_R23,
|
|
|
|
PT_R24, PT_R25, PT_R26, PT_R27, PT_R28, PT_R29, PT_R30, PT_R31,
|
|
|
|
PT_FPR0, PT_FPR0 + 2, PT_FPR0 + 4, PT_FPR0 + 6, PT_FPR0 + 8, PT_FPR0 + 10, PT_FPR0 + 12, PT_FPR0 + 14,
|
|
|
|
PT_FPR0 + 16, PT_FPR0 + 18, PT_FPR0 + 20, PT_FPR0 + 22, PT_FPR0 + 24, PT_FPR0 + 26, PT_FPR0 + 28, PT_FPR0 + 30,
|
|
|
|
PT_FPR0 + 32, PT_FPR0 + 34, PT_FPR0 + 36, PT_FPR0 + 38, PT_FPR0 + 40, PT_FPR0 + 42, PT_FPR0 + 44, PT_FPR0 + 46,
|
|
|
|
PT_FPR0 + 48, PT_FPR0 + 50, PT_FPR0 + 52, PT_FPR0 + 54, PT_FPR0 + 56, PT_FPR0 + 58, PT_FPR0 + 60, PT_FPR0 + 62,
|
|
|
|
PT_NIP, PT_MSR, PT_CCR, PT_LNK, PT_CTR, PT_XER, PT_MQ */
|
|
|
|
/* *INDENT_ON * */
|
2000-02-22 01:20:32 +00:00
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
static int
|
|
|
|
ppc_register_u_addr (int regno)
|
2000-02-22 01:20:32 +00:00
|
|
|
{
|
2001-11-30 02:14:08 +00:00
|
|
|
int u_addr = -1;
|
2002-01-24 02:58:24 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2003-12-03 19:37:03 +00:00
|
|
|
/* 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 (PTRACE_XFER_TYPE);
|
2001-11-30 02:14:08 +00:00
|
|
|
|
|
|
|
/* General purpose registers occupy 1 slot each in the buffer */
|
2004-05-04 17:58:31 +00:00
|
|
|
if (regno >= tdep->ppc_gp0_regnum
|
|
|
|
&& regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
|
2004-04-22 08:37:06 +00:00
|
|
|
u_addr = ((regno - tdep->ppc_gp0_regnum + PT_R0) * wordsize);
|
2001-11-30 02:14:08 +00:00
|
|
|
|
2003-06-13 00:03:03 +00:00
|
|
|
/* Floating point regs: eight bytes each in both 32- and 64-bit
|
|
|
|
ptrace interfaces. Thus, two slots each in 32-bit interface, one
|
|
|
|
slot each in 64-bit interface. */
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
if (tdep->ppc_fp0_regnum >= 0
|
|
|
|
&& regno >= tdep->ppc_fp0_regnum
|
* 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-05 01:46:55 +00:00
|
|
|
&& regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
|
|
|
|
u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8);
|
2001-11-30 02:14:08 +00:00
|
|
|
|
|
|
|
/* UISA special purpose registers: 1 slot each */
|
|
|
|
if (regno == PC_REGNUM)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_NIP * wordsize;
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_lr_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_LNK * wordsize;
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_cr_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_CCR * wordsize;
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_xer_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_XER * wordsize;
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_ctr_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_CTR * wordsize;
|
2003-06-12 23:30:40 +00:00
|
|
|
#ifdef PT_MQ
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_mq_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_MQ * wordsize;
|
2003-06-12 23:30:40 +00:00
|
|
|
#endif
|
2002-01-24 02:58:24 +00:00
|
|
|
if (regno == tdep->ppc_ps_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_MSR * wordsize;
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
if (tdep->ppc_fpscr_regnum >= 0
|
|
|
|
&& regno == tdep->ppc_fpscr_regnum)
|
2003-06-13 00:03:03 +00:00
|
|
|
u_addr = PT_FPSCR * wordsize;
|
2001-11-30 02:14:08 +00:00
|
|
|
|
|
|
|
return u_addr;
|
2000-02-22 01:20:32 +00:00
|
|
|
}
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
/* The Linux kernel ptrace interface for AltiVec registers uses the
|
|
|
|
registers set mechanism, as opposed to the interface for all the
|
|
|
|
other registers, that stores/fetches each register individually. */
|
|
|
|
static void
|
|
|
|
fetch_altivec_register (int tid, int regno)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int offset = 0;
|
|
|
|
gdb_vrregset_t regs;
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
if (errno == EIO)
|
|
|
|
{
|
|
|
|
have_ptrace_getvrregs = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
perror_with_name ("Unable to fetch AltiVec register");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
|
|
|
|
long on the hardware. We deal only with the lower 4 bytes of the
|
|
|
|
vector. VRSAVE is at the end of the array in a 4 bytes slot, so
|
|
|
|
there is no need to define an offset for it. */
|
|
|
|
if (regno == (tdep->ppc_vrsave_regnum - 1))
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
supply_register (regno,
|
|
|
|
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
|
|
|
|
}
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
/* Fetch the top 32 bits of TID's general-purpose registers and the
|
|
|
|
SPE-specific registers, and place the results in EVRREGSET. If we
|
|
|
|
don't support PTRACE_GETEVRREGS, then just fill EVRREGSET with
|
|
|
|
zeros.
|
|
|
|
|
|
|
|
All the logic to deal with whether or not the PTRACE_GETEVRREGS and
|
|
|
|
PTRACE_SETEVRREGS requests are supported is isolated here, and in
|
|
|
|
set_spe_registers. */
|
|
|
|
static void
|
|
|
|
get_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
|
|
|
|
{
|
|
|
|
if (have_ptrace_getsetevrregs)
|
|
|
|
{
|
|
|
|
if (ptrace (PTRACE_GETEVRREGS, tid, 0, evrregset) >= 0)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* EIO means that the PTRACE_GETEVRREGS request isn't supported;
|
|
|
|
we just return zeros. */
|
|
|
|
if (errno == EIO)
|
|
|
|
have_ptrace_getsetevrregs = 0;
|
|
|
|
else
|
|
|
|
/* Anything else needs to be reported. */
|
|
|
|
perror_with_name ("Unable to fetch SPE registers");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
memset (evrregset, 0, sizeof (*evrregset));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming TID refers to an SPE process, store the full 64-bit value
|
|
|
|
of TID's ev register EV_REGNUM in DEST, getting the high bits from
|
|
|
|
EVRREGS and the low bits from the kernel via ptrace. */
|
|
|
|
static void
|
|
|
|
read_spliced_spe_reg (int tid, int ev_regnum,
|
|
|
|
struct gdb_evrregset_t *evrregs,
|
|
|
|
char *dest)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
|
|
|
|
/* Make sure we're trying to read an EV register; that's all we
|
|
|
|
handle. */
|
|
|
|
gdb_assert (tdep->ppc_ev0_regnum <= ev_regnum
|
|
|
|
&& ev_regnum <= tdep->ppc_ev31_regnum);
|
|
|
|
|
|
|
|
/* Make sure the sizes for the splicing add up. */
|
|
|
|
gdb_assert (sizeof (evrregs->evr[0]) + sizeof (PTRACE_XFER_TYPE)
|
|
|
|
== register_size (current_gdbarch, ev_regnum));
|
|
|
|
|
|
|
|
{
|
|
|
|
/* The index of ev_regnum in evrregs->evr[]. */
|
|
|
|
int ev_index = ev_regnum - tdep->ppc_ev0_regnum;
|
|
|
|
|
|
|
|
/* The number of the corresponding general-purpose register, which
|
|
|
|
holds the lower 32 bits of the EV register. */
|
|
|
|
int gpr_regnum = tdep->ppc_gp0_regnum + ev_index;
|
|
|
|
|
|
|
|
/* The offset of gpr_regnum in the process's uarea. */
|
|
|
|
CORE_ADDR gpr_uoffset = ppc_register_u_addr (gpr_regnum);
|
|
|
|
|
|
|
|
/* The low word of the EV register's value. */
|
|
|
|
PTRACE_XFER_TYPE low_word;
|
|
|
|
|
|
|
|
/* The PTRACE_PEEKUSR / PT_READ_U ptrace requests need to be able
|
|
|
|
to return arbitrary register values, so they can't return -1 to
|
|
|
|
indicate an error. So we clear errno, and then check it after
|
|
|
|
the call. */
|
|
|
|
errno = 0;
|
|
|
|
low_word = ptrace (PT_READ_U, tid, (PTRACE_ARG3_TYPE) gpr_uoffset, 0);
|
|
|
|
|
|
|
|
if (errno != 0)
|
|
|
|
{
|
|
|
|
char message[128];
|
|
|
|
sprintf (message, "reading register %s (#%d)",
|
|
|
|
REGISTER_NAME (ev_regnum), ev_regnum);
|
|
|
|
perror_with_name (message);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
|
|
|
|
{
|
|
|
|
memcpy (dest, &evrregs->evr[ev_index],
|
|
|
|
sizeof (evrregs->evr[ev_index]));
|
|
|
|
* (PTRACE_XFER_TYPE *) (dest + sizeof (evrregs->evr[ev_index]))
|
|
|
|
= low_word;
|
|
|
|
}
|
|
|
|
else if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
|
|
|
|
{
|
|
|
|
* (PTRACE_XFER_TYPE *) dest = low_word;
|
|
|
|
memcpy (dest + sizeof (PTRACE_XFER_TYPE),
|
|
|
|
&evrregs->evr[ev_index], sizeof (evrregs->evr[ev_index]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* On SPE machines, supply the full value of the SPE register REGNO
|
|
|
|
from TID. This handles ev0 -- ev31 and acc, which are 64 bits
|
|
|
|
long, and spefscr, which is 32 bits long. */
|
|
|
|
static void
|
|
|
|
fetch_spe_register (int tid, int regno)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
struct gdb_evrregset_t evrregs;
|
|
|
|
|
|
|
|
get_spe_registers (tid, &evrregs);
|
|
|
|
|
|
|
|
if (tdep->ppc_ev0_regnum <= regno
|
|
|
|
&& regno <= tdep->ppc_ev31_regnum)
|
|
|
|
{
|
|
|
|
char buf[MAX_REGISTER_SIZE];
|
|
|
|
read_spliced_spe_reg (tid, regno, &evrregs, buf);
|
|
|
|
supply_register (regno, buf);
|
|
|
|
}
|
|
|
|
else if (regno == tdep->ppc_acc_regnum)
|
|
|
|
{
|
|
|
|
gdb_assert (sizeof (evrregs.acc)
|
|
|
|
== register_size (current_gdbarch, regno));
|
|
|
|
supply_register (regno, &evrregs.acc);
|
|
|
|
}
|
|
|
|
else if (regno == tdep->ppc_spefscr_regnum)
|
|
|
|
{
|
|
|
|
gdb_assert (sizeof (evrregs.spefscr)
|
|
|
|
== register_size (current_gdbarch, regno));
|
|
|
|
supply_register (regno, &evrregs.spefscr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert (0);
|
|
|
|
}
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
static void
|
2002-02-18 15:08:40 +00:00
|
|
|
fetch_register (int tid, int regno)
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
* 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-05 01:46:55 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2001-12-20 23:31:27 +00:00
|
|
|
/* This isn't really an address. But ptrace thinks of it as one. */
|
2004-05-21 23:30:48 +00:00
|
|
|
CORE_ADDR regaddr = ppc_register_u_addr (regno);
|
2004-06-04 23:07:28 +00:00
|
|
|
int bytes_transferred;
|
2001-12-20 23:31:27 +00:00
|
|
|
unsigned int offset; /* Offset of registers within the u area. */
|
2003-05-08 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh: Delete references to MAX_REGISTER_RAW_SIZE.
* gdbarch.h: Re-generate.
* defs.h (MAX_REGISTER_RAW_SIZE): Delete macro.
(legacy_max_register_raw_size): Delete declaration.
* regcache.c (legacy_max_register_raw_size): Delete function.
* valops.c: Replace MAX_REGISTER_RAW_SIZE with MAX_REGISTER_SIZE.
* target.c, stack.c, sparc-tdep.c, sh-tdep.c: Update.
* rs6000-tdep.c, rs6000-nat.c, remote.c, remote-sim.c: Update.
* remote-rdp.c, remote-array.c, regcache.c: Update.
* ppc-linux-nat.c, monitor.c, mn10300-tdep.c: Update.
* mips-tdep.c, mips-linux-tdep.c, m68klinux-nat.c: Update.
* infptrace.c, ia64-tdep.c, i386-tdep.c, frame.c: Update.
* findvar.c, dwarf2cfi.c: Update.
Index: tui/ChangeLog
2003-05-08 Andrew Cagney <cagney@redhat.com>
* tuiRegs.c: Use MAX_REGISTER_SIZE instead of
MAX_REGISTER_RAW_SIZE.
Index: mi/ChangeLog
2003-05-08 Andrew Cagney <cagney@redhat.com>
* mi-main.c (register_changed_p): Use MAX_REGISTER_SIZE instead of
MAX_REGISTER_RAW_SIZE.
2003-05-08 20:52:49 +00:00
|
|
|
char buf[MAX_REGISTER_SIZE];
|
2001-12-20 23:31:27 +00:00
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
/* Sanity check: this function should only be called to fetch raw
|
|
|
|
registers' values, never pseudoregisters' values. */
|
|
|
|
if (tdep->ppc_gp0_regnum <= regno
|
|
|
|
&& regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
|
|
|
|
gdb_assert (! tdep->ppc_gprs_pseudo_p);
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
if (altivec_register_p (regno))
|
|
|
|
{
|
|
|
|
/* If this is the first time through, or if it is not the first
|
|
|
|
time through, and we have comfirmed that there is kernel
|
|
|
|
support for such a ptrace request, then go and fetch the
|
|
|
|
register. */
|
|
|
|
if (have_ptrace_getvrregs)
|
|
|
|
{
|
|
|
|
fetch_altivec_register (tid, regno);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* If we have discovered that there is no ptrace support for
|
|
|
|
AltiVec registers, fall through and return zeroes, because
|
|
|
|
regaddr will be -1 in this case. */
|
|
|
|
}
|
2004-06-07 23:37:20 +00:00
|
|
|
else if (spe_register_p (regno))
|
|
|
|
{
|
|
|
|
fetch_spe_register (tid, regno);
|
|
|
|
return;
|
|
|
|
}
|
2002-02-21 22:04:46 +00:00
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
if (regaddr == -1)
|
|
|
|
{
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
|
2001-12-20 23:31:27 +00:00
|
|
|
supply_register (regno, buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-12-03 19:37:03 +00:00
|
|
|
/* Read the raw register using PTRACE_XFER_TYPE sized chunks. On a
|
|
|
|
32-bit platform, 64-bit floating-point registers will require two
|
|
|
|
transfers. */
|
2004-06-04 23:07:28 +00:00
|
|
|
for (bytes_transferred = 0;
|
2004-06-05 03:25:22 +00:00
|
|
|
bytes_transferred < register_size (current_gdbarch, regno);
|
2004-06-04 23:07:28 +00:00
|
|
|
bytes_transferred += sizeof (PTRACE_XFER_TYPE))
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
|
|
|
errno = 0;
|
2004-06-04 23:07:28 +00:00
|
|
|
*(PTRACE_XFER_TYPE *) & buf[bytes_transferred]
|
|
|
|
= ptrace (PT_READ_U, tid, (PTRACE_ARG3_TYPE) regaddr, 0);
|
2001-12-20 23:31:27 +00:00
|
|
|
regaddr += sizeof (PTRACE_XFER_TYPE);
|
|
|
|
if (errno != 0)
|
|
|
|
{
|
2004-06-02 18:17:05 +00:00
|
|
|
char message[128];
|
|
|
|
sprintf (message, "reading register %s (#%d)",
|
2001-12-20 23:31:27 +00:00
|
|
|
REGISTER_NAME (regno), regno);
|
2004-06-02 18:17:05 +00:00
|
|
|
perror_with_name (message);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
2003-12-03 19:37:03 +00:00
|
|
|
|
2004-06-04 23:07:28 +00:00
|
|
|
/* Now supply the register. Keep in mind that the regcache's idea
|
|
|
|
of the register's size may not be a multiple of sizeof
|
|
|
|
(PTRACE_XFER_TYPE). */
|
|
|
|
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
|
|
|
|
{
|
|
|
|
/* Little-endian values are always found at the left end of the
|
|
|
|
bytes transferred. */
|
|
|
|
regcache_raw_supply (current_regcache, regno, buf);
|
|
|
|
}
|
|
|
|
else if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
|
|
|
{
|
|
|
|
/* Big-endian values are found at the right end of the bytes
|
|
|
|
transferred. */
|
|
|
|
size_t padding = (bytes_transferred
|
|
|
|
- register_size (current_gdbarch, regno));
|
|
|
|
regcache_raw_supply (current_regcache, regno, buf + padding);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert (0);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
static void
|
|
|
|
supply_vrregset (gdb_vrregset_t *vrregsetp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
|
|
|
|
int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
for (i = 0; i < num_of_vrregs; i++)
|
|
|
|
{
|
|
|
|
/* The last 2 registers of this set are only 32 bit long, not
|
|
|
|
128. However an offset is necessary only for VSCR because it
|
|
|
|
occupies a whole vector, while VRSAVE occupies a full 4 bytes
|
|
|
|
slot. */
|
|
|
|
if (i == (num_of_vrregs - 2))
|
|
|
|
supply_register (tdep->ppc_vr0_regnum + i,
|
|
|
|
*vrregsetp + i * vrregsize + offset);
|
|
|
|
else
|
|
|
|
supply_register (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fetch_altivec_registers (int tid)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
gdb_vrregset_t regs;
|
|
|
|
|
|
|
|
ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
if (errno == EIO)
|
|
|
|
{
|
|
|
|
have_ptrace_getvrregs = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
perror_with_name ("Unable to fetch AltiVec registers");
|
|
|
|
}
|
|
|
|
supply_vrregset (®s);
|
|
|
|
}
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
/* On SPE machines, fetch the full 64 bits of all the general-purpose
|
|
|
|
registers, as well as the SPE-specific registers 'acc' and
|
|
|
|
'spefscr'. */
|
|
|
|
static void
|
|
|
|
fetch_spe_registers (int tid)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
struct gdb_evrregset_t evrregs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
get_spe_registers (tid, &evrregs);
|
|
|
|
|
|
|
|
/* Splice and supply each of the EV registers. */
|
|
|
|
for (i = 0; i < ppc_num_gprs; i++)
|
|
|
|
{
|
|
|
|
char buf[MAX_REGISTER_SIZE];
|
|
|
|
|
|
|
|
read_spliced_spe_reg (tid, tdep->ppc_ev0_regnum + i, &evrregs, buf);
|
|
|
|
supply_register (tdep->ppc_ev0_regnum + i, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Supply the SPE-specific registers. */
|
|
|
|
supply_register (tdep->ppc_acc_regnum, &evrregs.acc);
|
|
|
|
supply_register (tdep->ppc_spefscr_regnum, &evrregs.spefscr);
|
|
|
|
}
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
static void
|
2002-02-18 15:08:40 +00:00
|
|
|
fetch_ppc_registers (int tid)
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
|
|
|
int i;
|
2002-02-21 22:04:46 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
if (! tdep->ppc_gprs_pseudo_p)
|
|
|
|
for (i = 0; i < ppc_num_gprs; i++)
|
|
|
|
fetch_register (tid, tdep->ppc_gp0_regnum + i);
|
2004-05-05 01:48:37 +00:00
|
|
|
if (tdep->ppc_fp0_regnum >= 0)
|
|
|
|
for (i = 0; i < ppc_num_fprs; i++)
|
|
|
|
fetch_register (tid, tdep->ppc_fp0_regnum + i);
|
|
|
|
fetch_register (tid, PC_REGNUM);
|
|
|
|
if (tdep->ppc_ps_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_ps_regnum);
|
|
|
|
if (tdep->ppc_cr_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_cr_regnum);
|
|
|
|
if (tdep->ppc_lr_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_lr_regnum);
|
|
|
|
if (tdep->ppc_ctr_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_ctr_regnum);
|
|
|
|
if (tdep->ppc_xer_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_xer_regnum);
|
2002-04-11 19:08:56 +00:00
|
|
|
if (tdep->ppc_mq_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_mq_regnum);
|
2004-05-05 01:48:37 +00:00
|
|
|
if (tdep->ppc_fpscr_regnum != -1)
|
|
|
|
fetch_register (tid, tdep->ppc_fpscr_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
if (have_ptrace_getvrregs)
|
|
|
|
if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
|
|
|
|
fetch_altivec_registers (tid);
|
2004-06-07 23:37:20 +00:00
|
|
|
if (tdep->ppc_ev0_regnum >= 0)
|
|
|
|
fetch_spe_registers (tid);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fetch registers from the child process. Fetch all registers if
|
|
|
|
regno == -1, otherwise fetch all general registers or all floating
|
|
|
|
point registers depending upon the value of regno. */
|
|
|
|
void
|
|
|
|
fetch_inferior_registers (int regno)
|
|
|
|
{
|
2002-02-21 22:04:46 +00:00
|
|
|
/* Overload thread id onto process id */
|
2002-02-18 15:08:40 +00:00
|
|
|
int tid = TIDGET (inferior_ptid);
|
|
|
|
|
|
|
|
/* No thread id, just use process id */
|
|
|
|
if (tid == 0)
|
|
|
|
tid = PIDGET (inferior_ptid);
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
if (regno == -1)
|
2002-02-18 15:08:40 +00:00
|
|
|
fetch_ppc_registers (tid);
|
2001-12-20 23:31:27 +00:00
|
|
|
else
|
2002-02-18 15:08:40 +00:00
|
|
|
fetch_register (tid, regno);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Store one register. */
|
2002-02-21 22:04:46 +00:00
|
|
|
static void
|
|
|
|
store_altivec_register (int tid, int regno)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int offset = 0;
|
|
|
|
gdb_vrregset_t regs;
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
if (errno == EIO)
|
|
|
|
{
|
|
|
|
have_ptrace_getvrregs = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
perror_with_name ("Unable to fetch AltiVec register");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
|
|
|
|
long on the hardware. */
|
|
|
|
if (regno == (tdep->ppc_vrsave_regnum - 1))
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
regcache_collect (regno,
|
|
|
|
regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
|
|
|
|
|
|
|
|
ret = ptrace (PTRACE_SETVRREGS, tid, 0, ®s);
|
|
|
|
if (ret < 0)
|
|
|
|
perror_with_name ("Unable to store AltiVec register");
|
|
|
|
}
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
/* Assuming TID referrs to an SPE process, set the top halves of TID's
|
|
|
|
general-purpose registers and its SPE-specific registers to the
|
|
|
|
values in EVRREGSET. If we don't support PTRACE_SETEVRREGS, do
|
|
|
|
nothing.
|
|
|
|
|
|
|
|
All the logic to deal with whether or not the PTRACE_GETEVRREGS and
|
|
|
|
PTRACE_SETEVRREGS requests are supported is isolated here, and in
|
|
|
|
get_spe_registers. */
|
|
|
|
static void
|
|
|
|
set_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
|
|
|
|
{
|
|
|
|
if (have_ptrace_getsetevrregs)
|
|
|
|
{
|
|
|
|
if (ptrace (PTRACE_SETEVRREGS, tid, 0, evrregset) >= 0)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* EIO means that the PTRACE_SETEVRREGS request isn't
|
|
|
|
supported; we fail silently, and don't try the call
|
|
|
|
again. */
|
|
|
|
if (errno == EIO)
|
|
|
|
have_ptrace_getsetevrregs = 0;
|
|
|
|
else
|
|
|
|
/* Anything else needs to be reported. */
|
|
|
|
perror_with_name ("Unable to set SPE registers");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Store the bytes at SRC as the contents of TID's EV register EV_REGNUM.
|
|
|
|
Write the less significant word to TID using ptrace, and copy the
|
|
|
|
more significant word to the appropriate slot in EVRREGS. */
|
|
|
|
static void
|
|
|
|
write_spliced_spe_reg (int tid, int ev_regnum,
|
|
|
|
struct gdb_evrregset_t *evrregs,
|
|
|
|
char *src)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
|
|
|
|
/* Make sure we're trying to write an EV register; that's all we
|
|
|
|
handle. */
|
|
|
|
gdb_assert (tdep->ppc_ev0_regnum <= ev_regnum
|
|
|
|
&& ev_regnum <= tdep->ppc_ev31_regnum);
|
|
|
|
|
|
|
|
/* Make sure the sizes for the splicing add up. */
|
|
|
|
gdb_assert (sizeof (evrregs->evr[0]) + sizeof (PTRACE_XFER_TYPE)
|
|
|
|
== register_size (current_gdbarch, ev_regnum));
|
|
|
|
|
|
|
|
{
|
|
|
|
int ev_index = ev_regnum - tdep->ppc_ev0_regnum;
|
|
|
|
|
|
|
|
/* The number of the corresponding general-purpose register, which
|
|
|
|
holds the lower 32 bits of the EV register. */
|
|
|
|
int gpr_regnum = tdep->ppc_gp0_regnum + ev_index;
|
|
|
|
|
|
|
|
/* The offset of gpr_regnum in the process's uarea. */
|
|
|
|
CORE_ADDR gpr_uoffset = ppc_register_u_addr (gpr_regnum);
|
|
|
|
|
|
|
|
/* The PTRACE_POKEUSR / PT_WRITE_U ptrace requests need to be able
|
|
|
|
to return arbitrary register values, so they can't return -1 to
|
|
|
|
indicate an error. So we clear errno, and check it again
|
|
|
|
afterwards. */
|
|
|
|
errno = 0;
|
|
|
|
|
|
|
|
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
|
|
|
|
{
|
|
|
|
memcpy (&evrregs->evr[ev_index], src, sizeof (evrregs->evr[ev_index]));
|
|
|
|
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) gpr_uoffset,
|
|
|
|
* (PTRACE_XFER_TYPE *) (src + sizeof (evrregs->evr[0])));
|
|
|
|
}
|
|
|
|
else if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
|
|
|
|
{
|
|
|
|
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) gpr_uoffset,
|
|
|
|
* (PTRACE_XFER_TYPE *) src);
|
|
|
|
memcpy (&evrregs->evr[ev_index], src + sizeof (PTRACE_XFER_TYPE),
|
|
|
|
sizeof (evrregs->evr[ev_index]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert (0);
|
|
|
|
|
|
|
|
if (errno != 0)
|
|
|
|
{
|
|
|
|
char message[128];
|
|
|
|
sprintf (message, "writing register %s (#%d)",
|
|
|
|
REGISTER_NAME (ev_regnum), ev_regnum);
|
|
|
|
perror_with_name (message);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write GDB's value for the SPE register REGNO to TID. */
|
|
|
|
static void
|
|
|
|
store_spe_register (int tid, int regno)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
struct gdb_evrregset_t evrregs;
|
|
|
|
|
|
|
|
/* We can only read and write the entire EVR register set at a time,
|
|
|
|
so to write just a single register, we do a read-modify-write
|
|
|
|
maneuver. */
|
|
|
|
get_spe_registers (tid, &evrregs);
|
|
|
|
|
|
|
|
if (tdep->ppc_ev0_regnum >= 0
|
|
|
|
&& tdep->ppc_ev0_regnum <= regno && regno <= tdep->ppc_ev31_regnum)
|
|
|
|
{
|
|
|
|
char buf[MAX_REGISTER_SIZE];
|
|
|
|
regcache_collect (regno, buf);
|
|
|
|
write_spliced_spe_reg (tid, regno, &evrregs, buf);
|
|
|
|
}
|
|
|
|
else if (tdep->ppc_acc_regnum >= 0
|
|
|
|
&& regno == tdep->ppc_acc_regnum)
|
|
|
|
{
|
|
|
|
gdb_assert (sizeof (evrregs.acc)
|
|
|
|
== register_size (current_gdbarch, regno));
|
|
|
|
regcache_collect (regno, &evrregs.acc);
|
|
|
|
}
|
|
|
|
else if (tdep->ppc_spefscr_regnum >= 0
|
|
|
|
&& regno == tdep->ppc_spefscr_regnum)
|
|
|
|
{
|
|
|
|
gdb_assert (sizeof (evrregs.spefscr)
|
|
|
|
== register_size (current_gdbarch, regno));
|
|
|
|
regcache_collect (regno, &evrregs.spefscr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gdb_assert (0);
|
|
|
|
|
|
|
|
/* Write back the modified register set. */
|
|
|
|
set_spe_registers (tid, &evrregs);
|
|
|
|
}
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
static void
|
2002-02-18 15:08:40 +00:00
|
|
|
store_register (int tid, int regno)
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
* 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-05 01:46:55 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2001-12-20 23:31:27 +00:00
|
|
|
/* This isn't really an address. But ptrace thinks of it as one. */
|
|
|
|
CORE_ADDR regaddr = ppc_register_u_addr (regno);
|
2003-09-14 Andrew Cagney <cagney@redhat.com>
* alpha-nat.c: Remove some occurances of "register".
* alpha-tdep.c, arm-tdep.c, blockframe.c, breakpoint.c: Ditto.
* buildsym.c, c-typeprint.c, c-valprint.c, coffread.c: Ditto.
* corefile.c, cp-support.c, cp-valprint.c, cris-tdep.c: Ditto.
* dbxread.c, dcache.c, dwarf2read.c, elfread.c: Ditto.
* environ.c, eval.c, event-top.c, f-typeprint.c: Ditto.
* f-valprint.c, findvar.c, frame.c, gdbtypes.c: Ditto.
* h8300-tdep.c, hppa-tdep.c, hppab-nat.c, hppah-nat.c: Ditto.
* hppam3-nat.c, hpread.c, ia64-aix-nat.c, ia64-linux-nat.c: Ditto.
* infcall.c, infcmd.c, inflow.c, infptrace.c, infrun.c: Ditto.
* infttrace.c, irix5-nat.c, jv-typeprint.c: Ditto.
* jv-valprint.c, m68k-tdep.c, m68klinux-nat.c, main.c: Ditto.
* mdebugread.c, minsyms.c, mips-linux-tdep.c: Ditto.
* mips-nat.c, mips-tdep.c, mipsread.c, mipsv4-nat.c: Ditto.
* ns32k-tdep.c, objfiles.c, p-typeprint.c: Ditto.
* p-valprint.c, ppc-linux-nat.c, printcmd.c: Ditto.
* remote-mips.c, remote-vx.c, rs6000-nat.c: Ditto.
* rs6000-tdep.c, scm-exp.c, sh-tdep.c, sh64-tdep.c: Ditto.
* solib.c, somread.c, source.c, sparc-tdep.c: Ditto.
* stabsread.c, stack.c, standalone.c, symfile.c: Ditto.
* symmisc.c, symtab.c, top.c, tracepoint.c: Ditto.
* typeprint.c, utils.c, valarith.c, valops.c: Ditto.
* values.c, vax-tdep.c, xcoffread.c: Ditto.
2003-09-14 16:32:14 +00:00
|
|
|
int i;
|
2004-06-04 23:07:28 +00:00
|
|
|
size_t bytes_to_transfer;
|
2003-05-08 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh: Delete references to MAX_REGISTER_RAW_SIZE.
* gdbarch.h: Re-generate.
* defs.h (MAX_REGISTER_RAW_SIZE): Delete macro.
(legacy_max_register_raw_size): Delete declaration.
* regcache.c (legacy_max_register_raw_size): Delete function.
* valops.c: Replace MAX_REGISTER_RAW_SIZE with MAX_REGISTER_SIZE.
* target.c, stack.c, sparc-tdep.c, sh-tdep.c: Update.
* rs6000-tdep.c, rs6000-nat.c, remote.c, remote-sim.c: Update.
* remote-rdp.c, remote-array.c, regcache.c: Update.
* ppc-linux-nat.c, monitor.c, mn10300-tdep.c: Update.
* mips-tdep.c, mips-linux-tdep.c, m68klinux-nat.c: Update.
* infptrace.c, ia64-tdep.c, i386-tdep.c, frame.c: Update.
* findvar.c, dwarf2cfi.c: Update.
Index: tui/ChangeLog
2003-05-08 Andrew Cagney <cagney@redhat.com>
* tuiRegs.c: Use MAX_REGISTER_SIZE instead of
MAX_REGISTER_RAW_SIZE.
Index: mi/ChangeLog
2003-05-08 Andrew Cagney <cagney@redhat.com>
* mi-main.c (register_changed_p): Use MAX_REGISTER_SIZE instead of
MAX_REGISTER_RAW_SIZE.
2003-05-08 20:52:49 +00:00
|
|
|
char buf[MAX_REGISTER_SIZE];
|
2001-12-20 23:31:27 +00:00
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
/* Sanity check: this function should only be called to store raw
|
|
|
|
registers' values, never pseudoregisters' values. */
|
|
|
|
if (tdep->ppc_gp0_regnum <= regno
|
|
|
|
&& regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
|
|
|
|
gdb_assert (! tdep->ppc_gprs_pseudo_p);
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
if (altivec_register_p (regno))
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
2002-02-21 22:04:46 +00:00
|
|
|
store_altivec_register (tid, regno);
|
2001-12-20 23:31:27 +00:00
|
|
|
return;
|
|
|
|
}
|
2004-06-07 23:37:20 +00:00
|
|
|
else if (spe_register_p (regno))
|
|
|
|
{
|
|
|
|
store_spe_register (tid, regno);
|
|
|
|
return;
|
|
|
|
}
|
2001-12-20 23:31:27 +00:00
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
if (regaddr == -1)
|
|
|
|
return;
|
|
|
|
|
2004-06-04 23:07:28 +00:00
|
|
|
/* First collect the register. Keep in mind that the regcache's
|
|
|
|
idea of the register's size may not be a multiple of sizeof
|
|
|
|
(PTRACE_XFER_TYPE). */
|
2003-12-03 19:37:03 +00:00
|
|
|
memset (buf, 0, sizeof buf);
|
2004-06-04 23:07:28 +00:00
|
|
|
bytes_to_transfer = align_up (register_size (current_gdbarch, regno),
|
|
|
|
sizeof (PTRACE_XFER_TYPE));
|
|
|
|
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
|
|
|
|
{
|
|
|
|
/* Little-endian values always sit at the left end of the buffer. */
|
|
|
|
regcache_raw_collect (current_regcache, regno, buf);
|
|
|
|
}
|
|
|
|
else if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
|
|
|
|
{
|
|
|
|
/* Big-endian values sit at the right end of the buffer. */
|
|
|
|
size_t padding = (bytes_to_transfer
|
|
|
|
- register_size (current_gdbarch, regno));
|
|
|
|
regcache_raw_collect (current_regcache, regno, buf + padding);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < bytes_to_transfer; i += sizeof (PTRACE_XFER_TYPE))
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
|
|
|
errno = 0;
|
|
|
|
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
|
|
|
|
*(PTRACE_XFER_TYPE *) & buf[i]);
|
|
|
|
regaddr += sizeof (PTRACE_XFER_TYPE);
|
2002-04-11 19:08:56 +00:00
|
|
|
|
|
|
|
if (errno == EIO
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
&& regno == tdep->ppc_fpscr_regnum)
|
2002-04-11 19:08:56 +00:00
|
|
|
{
|
|
|
|
/* Some older kernel versions don't allow fpscr to be written. */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
if (errno != 0)
|
|
|
|
{
|
2004-06-02 18:17:05 +00:00
|
|
|
char message[128];
|
|
|
|
sprintf (message, "writing register %s (#%d)",
|
2001-12-20 23:31:27 +00:00
|
|
|
REGISTER_NAME (regno), regno);
|
2004-06-02 18:17:05 +00:00
|
|
|
perror_with_name (message);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
static void
|
|
|
|
fill_vrregset (gdb_vrregset_t *vrregsetp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
|
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_RAW_SIZE): Rename
REGISTER_RAW_SIZE.
* gdbarch.h, gdbarch.c: Re-generate.
* aix-thread.c, alpha-tdep.h, arm-tdep.c, core-sol2.c: Update.
* cris-tdep.c, dve3900-rom.c, findvar.c, frame.c: Update.
* hppa-tdep.c, hppab-nat.c, hppah-nat.c, hppam3-nat.c: Update.
* hpux-thread.c, i386gnu-nat.c, ia64-aix-nat.c: Update.
* ia64-linux-nat.c, ia64-tdep.c, infcmd.c, infptrace.c: Update.
* infrun.c, irix5-nat.c, lynx-nat.c, mips-linux-tdep.c: Update.
* mips-nat.c, mips-tdep.c, mipsv4-nat.c, mn10300-tdep.c: Update.
* monitor.c, ns32k-tdep.c, ppc-linux-nat.c, regcache.c: Update.
* remote-e7000.c, remote-mips.c, remote-sim.c: Update.
* remote-vxmips.c, remote-vxsparc.c, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, rs6000-tdep.c, s390-tdep.c: Update.
* sh64-tdep.c, sparc-nat.c, sparc-tdep.c, stack.c: Update.
* target.c, tracepoint.c, v850-tdep.c, v850ice.c, valops.c: Update.
* vax-tdep.c, vax-tdep.h, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/m68k/tm-delta68.h, config/m68k/tm-vx68.h: Update.
* config/sparc/tm-sparc.h, config/sparc/tm-sparclynx.h: Update.
2003-10-02 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Rename
REGISTER_RAW_SIZE to DEPRECATED_REGISTER_RAW_SIZE.
* gdb.texinfo (Packets, Stop Reply Packets): Ditto.
* gdbint.texinfo (Target Architecture Definition): Rename
2003-10-02 Andrew Cagney <cagney@redhat.com>
* mi-main.c: Rename REGISTER_RAW_SIZE to
DEPRECATED_REGISTER_RAW_SIZE.
2003-10-02 20:28:31 +00:00
|
|
|
int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
|
|
|
|
int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
|
|
|
|
for (i = 0; i < num_of_vrregs; i++)
|
|
|
|
{
|
|
|
|
/* The last 2 registers of this set are only 32 bit long, not
|
|
|
|
128, but only VSCR is fetched as a 16 bytes quantity. */
|
|
|
|
if (i == (num_of_vrregs - 2))
|
|
|
|
regcache_collect (tdep->ppc_vr0_regnum + i,
|
|
|
|
*vrregsetp + i * vrregsize + offset);
|
|
|
|
else
|
|
|
|
regcache_collect (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
store_altivec_registers (int tid)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
gdb_vrregset_t regs;
|
|
|
|
|
2003-05-28 22:39:02 +00:00
|
|
|
ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s);
|
2002-02-21 22:04:46 +00:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
if (errno == EIO)
|
|
|
|
{
|
|
|
|
have_ptrace_getvrregs = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
perror_with_name ("Couldn't get AltiVec registers");
|
|
|
|
}
|
|
|
|
|
|
|
|
fill_vrregset (®s);
|
|
|
|
|
2003-05-28 22:39:02 +00:00
|
|
|
if (ptrace (PTRACE_SETVRREGS, tid, 0, ®s) < 0)
|
2002-02-21 22:04:46 +00:00
|
|
|
perror_with_name ("Couldn't write AltiVec registers");
|
|
|
|
}
|
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
static void
|
|
|
|
store_spe_registers (tid)
|
|
|
|
{
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
|
|
|
struct gdb_evrregset_t evrregs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* The code below should store to every field of evrregs; if that
|
|
|
|
doesn't happen, make it obvious by initializing it with
|
|
|
|
suspicious values. */
|
|
|
|
memset (&evrregs, 42, sizeof (evrregs));
|
|
|
|
|
|
|
|
for (i = 0; i < ppc_num_gprs; i++)
|
|
|
|
{
|
|
|
|
char buf[MAX_REGISTER_SIZE];
|
|
|
|
|
|
|
|
regcache_collect (tdep->ppc_ev0_regnum + i, buf);
|
|
|
|
write_spliced_spe_reg (tid, tdep->ppc_ev0_regnum + i, &evrregs, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
gdb_assert (sizeof (evrregs.acc)
|
|
|
|
== register_size (current_gdbarch, tdep->ppc_acc_regnum));
|
|
|
|
regcache_collect (tdep->ppc_acc_regnum, &evrregs.acc);
|
|
|
|
gdb_assert (sizeof (evrregs.spefscr)
|
|
|
|
== register_size (current_gdbarch, tdep->ppc_spefscr_regnum));
|
|
|
|
regcache_collect (tdep->ppc_acc_regnum, &evrregs.spefscr);
|
|
|
|
|
|
|
|
set_spe_registers (tid, &evrregs);
|
|
|
|
}
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
static void
|
2002-02-18 15:08:40 +00:00
|
|
|
store_ppc_registers (int tid)
|
2001-12-20 23:31:27 +00:00
|
|
|
{
|
|
|
|
int i;
|
2002-02-21 22:04:46 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2001-12-20 23:31:27 +00:00
|
|
|
|
2004-06-07 23:37:20 +00:00
|
|
|
if (! tdep->ppc_gprs_pseudo_p)
|
|
|
|
for (i = 0; i < ppc_num_gprs; i++)
|
|
|
|
store_register (tid, tdep->ppc_gp0_regnum + i);
|
2004-05-05 01:48:37 +00:00
|
|
|
if (tdep->ppc_fp0_regnum >= 0)
|
|
|
|
for (i = 0; i < ppc_num_fprs; i++)
|
|
|
|
store_register (tid, tdep->ppc_fp0_regnum + i);
|
|
|
|
store_register (tid, PC_REGNUM);
|
|
|
|
if (tdep->ppc_ps_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_ps_regnum);
|
|
|
|
if (tdep->ppc_cr_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_cr_regnum);
|
|
|
|
if (tdep->ppc_lr_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_lr_regnum);
|
|
|
|
if (tdep->ppc_ctr_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_ctr_regnum);
|
|
|
|
if (tdep->ppc_xer_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_xer_regnum);
|
2002-04-11 19:08:56 +00:00
|
|
|
if (tdep->ppc_mq_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_mq_regnum);
|
2004-05-05 01:48:37 +00:00
|
|
|
if (tdep->ppc_fpscr_regnum != -1)
|
|
|
|
store_register (tid, tdep->ppc_fpscr_regnum);
|
2002-02-21 22:04:46 +00:00
|
|
|
if (have_ptrace_getvrregs)
|
|
|
|
if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
|
|
|
|
store_altivec_registers (tid);
|
2004-06-07 23:37:20 +00:00
|
|
|
if (tdep->ppc_ev0_regnum >= 0)
|
|
|
|
store_spe_registers (tid);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
store_inferior_registers (int regno)
|
|
|
|
{
|
2002-02-18 15:08:40 +00:00
|
|
|
/* Overload thread id onto process id */
|
|
|
|
int tid = TIDGET (inferior_ptid);
|
|
|
|
|
|
|
|
/* No thread id, just use process id */
|
|
|
|
if (tid == 0)
|
|
|
|
tid = PIDGET (inferior_ptid);
|
|
|
|
|
2001-12-20 23:31:27 +00:00
|
|
|
if (regno >= 0)
|
2002-02-18 15:08:40 +00:00
|
|
|
store_register (tid, regno);
|
2001-12-20 23:31:27 +00:00
|
|
|
else
|
2002-02-18 15:08:40 +00:00
|
|
|
store_ppc_registers (tid);
|
2001-12-20 23:31:27 +00:00
|
|
|
}
|
|
|
|
|
2000-02-22 18:47:41 +00:00
|
|
|
void
|
2000-09-30 05:41:39 +00:00
|
|
|
supply_gregset (gdb_gregset_t *gregsetp)
|
2000-02-22 01:20:32 +00:00
|
|
|
{
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
/* 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 (PTRACE_XFER_TYPE);
|
|
|
|
ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
|
|
|
|
sizeof (gdb_gregset_t), wordsize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
right_fill_reg (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 (PTRACE_XFER_TYPE);
|
|
|
|
/* Right fill the register. */
|
|
|
|
regcache_raw_collect (current_regcache, regnum,
|
|
|
|
((bfd_byte *) reg
|
|
|
|
+ wordsize
|
|
|
|
- register_size (current_gdbarch, regnum)));
|
2000-02-22 01:20:32 +00:00
|
|
|
}
|
|
|
|
|
2000-09-18 01:08:24 +00:00
|
|
|
void
|
2000-09-30 05:41:39 +00:00
|
|
|
fill_gregset (gdb_gregset_t *gregsetp, int regno)
|
2000-09-18 01:08:24 +00:00
|
|
|
{
|
|
|
|
int regi;
|
2001-07-05 23:22:04 +00:00
|
|
|
elf_greg_t *regp = (elf_greg_t *) gregsetp;
|
2002-01-24 02:58:24 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
const int elf_ngreg = 48;
|
|
|
|
|
|
|
|
|
|
|
|
/* Start with zeros. */
|
|
|
|
memset (regp, 0, elf_ngreg * sizeof (*regp));
|
2000-09-18 01:08:24 +00:00
|
|
|
|
2004-05-13 19:36:05 +00:00
|
|
|
for (regi = 0; regi < ppc_num_gprs; regi++)
|
2000-09-18 01:08:24 +00:00
|
|
|
{
|
2004-05-13 19:27:07 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi)
|
|
|
|
right_fill_reg (tdep->ppc_gp0_regnum + regi, (regp + PT_R0 + regi));
|
2000-09-18 01:08:24 +00:00
|
|
|
}
|
|
|
|
|
2001-11-30 02:14:08 +00:00
|
|
|
if ((regno == -1) || regno == PC_REGNUM)
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
right_fill_reg (PC_REGNUM, regp + PT_NIP);
|
2002-02-18 15:08:40 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
|
2002-02-18 15:08:40 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
|
2002-01-24 02:58:24 +00:00
|
|
|
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
|
2002-02-18 15:08:40 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
|
2002-01-24 02:58:24 +00:00
|
|
|
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
|
2002-02-18 15:08:40 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
|
2003-06-12 23:30:40 +00:00
|
|
|
#ifdef PT_MQ
|
2002-04-11 19:08:56 +00:00
|
|
|
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
|
|
|
|
&& (tdep->ppc_mq_regnum != -1))
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
|
2003-06-12 23:30:40 +00:00
|
|
|
#endif
|
2002-02-18 15:08:40 +00:00
|
|
|
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
|
2000-09-18 01:08:24 +00:00
|
|
|
}
|
|
|
|
|
2000-02-22 18:47:41 +00:00
|
|
|
void
|
2000-09-30 05:41:39 +00:00
|
|
|
supply_fpregset (gdb_fpregset_t * fpregsetp)
|
2000-02-22 01:20:32 +00:00
|
|
|
{
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
|
|
|
|
sizeof (gdb_fpregset_t));
|
2000-02-22 01:20:32 +00:00
|
|
|
}
|
2000-09-18 01:08:24 +00:00
|
|
|
|
2002-02-21 22:04:46 +00:00
|
|
|
/* 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. */
|
2000-09-18 01:08:24 +00:00
|
|
|
void
|
2000-09-30 05:41:39 +00:00
|
|
|
fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
|
2000-09-18 01:08:24 +00:00
|
|
|
{
|
|
|
|
int regi;
|
2002-04-11 19:08:56 +00:00
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
2004-03-15 Andrew Cagney <cagney@redhat.com>
* ppc-tdep.h: Update copyright.
(ppc_linux_supply_gregset, ppc_linux_supply_fpregset): Change
function signatures to match "regsets.h".
* ppc-linux-tdep.c: Include "regset.h".
(ELF_GREGSET_SIZE): Delete.
(right_supply_register): New function.
(ppc_linux_supply_fpregset, ppc_linux_supply_gregset): Rewrite
using right_supply_register.
(ppc32_linux_supply_gregset, ppc64_linux_supply_gregset): New
functions.
(ppc64_linux_gregset, ppc32_linux_gregset): Define.
(ppc_linux_init_abi): Register ppc_linux_regset_from_core_section.
(_initialize_ppc_linux_tdep): Do not register
ppc_linux_regset_core_fns.
(ppc_linux_regset_from_core_section): Replace
fetch_core_registers.
(ppc_linux_regset_core_fns): Delete.
* ppc-linux-nat.c: (right_fill_reg): New function.
(supply_gregset): Update call to ppc_linux_supply_gregset.
(fill_gregset): Clear the register set, use right_fill_reg.
(supply_fpregset): Update call to ppc_linux_supply_fpregset.
(fill_fpregset): Use right_fill_reg, correctly compute FP offsets.
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.28
diff -u -r1.28 ppc-linux-nat.c
--- ppc-linux-nat.c 8 Mar 2004 01:45:02 -0000 1.28
+++ ppc-linux-nat.c 15 Mar 2004 21:28:31 -0000
@@ -507,7 +507,24 @@
void
supply_gregset (gdb_gregset_t *gregsetp)
{
- ppc_linux_supply_gregset ((char *) gregsetp);
+ /* 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 (PTRACE_XFER_TYPE);
+ ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ sizeof (gdb_gregset_t), wordsize);
+}
+
+static void
+right_fill_reg (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 (PTRACE_XFER_TYPE);
+ /* Right fill the register. */
+ regcache_raw_collect (current_regcache, regnum,
+ ((bfd_byte *) reg
+ + wordsize
+ - register_size (current_gdbarch, regnum)));
}
void
@@ -516,36 +533,42 @@
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ const int elf_ngreg = 48;
+
+
+ /* Start with zeros. */
+ memset (regp, 0, elf_ngreg * sizeof (*regp));
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
- regcache_collect (regi, regp + PT_R0 + regi);
+ right_fill_reg (regi, (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- regcache_collect (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
- regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
+ right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset ((char *) fpregsetp);
+ ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ sizeof (gdb_fpregset_t));
}
/* Given a pointer to a floating point register set in /proc format
@@ -557,12 +580,13 @@
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ bfd_byte *fpp = (void *) fpregsetp;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
- regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
+ regcache_collect (FP0_REGNUM + regi, fpp + 8 * regi);
}
if ((regno == -1) || regno == tdep->ppc_fpscr_regnum)
- regcache_collect (tdep->ppc_fpscr_regnum, (char *) (*fpregsetp + regi));
+ right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
}
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.50
diff -u -r1.50 ppc-linux-tdep.c
--- ppc-linux-tdep.c 16 Feb 2004 21:49:22 -0000 1.50
+++ ppc-linux-tdep.c 15 Mar 2004 21:28:31 -0000
@@ -32,7 +32,7 @@
#include "regcache.h"
#include "value.h"
#include "osabi.h"
-
+#include "regset.h"
#include "solib-svr4.h"
#include "ppc-tdep.h"
@@ -959,81 +959,114 @@
};
enum {
- ELF_GREGSET_SIZE = (ELF_NGREG * 4),
ELF_FPREGSET_SIZE = (ELF_NFPREG * 8)
};
+static void
+right_supply_register (struct regcache *regcache, int wordsize, int regnum,
+ 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 (char *buf)
+ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ int wordsize)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ 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 < 32; regi++)
- supply_register (regi, buf + 4 * regi);
+ right_supply_register (regcache, wordsize, 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);
+}
- supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP);
- supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK);
- supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR);
- supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER);
- supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR);
- if (tdep->ppc_mq_regnum != -1)
- supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ);
- supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR);
+static void
+ppc32_linux_supply_gregset (const struct regset *regset,
+ struct regcache *regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 4);
}
+static struct regset ppc32_linux_gregset = {
+ NULL, ppc32_linux_supply_gregset
+};
+
+static void
+ppc64_linux_supply_gregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *gregs, size_t size)
+{
+ ppc_linux_supply_gregset (regcache, regnum, gregs, size, 8);
+}
+
+static struct regset ppc64_linux_gregset = {
+ NULL, ppc64_linux_supply_gregset
+};
+
void
-ppc_linux_supply_fpregset (char *buf)
+ppc_linux_supply_fpregset (const struct regset *regset,
+ struct regcache * regcache,
+ int regnum, const void *fpset, size_t size)
{
int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *regcache_arch = get_regcache_arch (regcache);
+ struct gdbarch_tdep *regcache_tdep = gdbarch_tdep (regcache_arch);
+ const bfd_byte *buf = fpset;
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi, buf + 8 * regi);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi, buf + 8 * regi);
/* The FPSCR is stored in the low order word of the last doubleword in the
fpregset. */
- supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4);
+ regcache_raw_supply (regcache, regcache_tdep->ppc_fpscr_regnum,
+ buf + 8 * 32 + 4);
}
-/*
- Use a local version of this function to get the correct types for regsets.
-*/
+static struct regset ppc_linux_fpregset = { NULL, ppc_linux_supply_fpregset };
-static void
-fetch_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
+static const struct regset *
+ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
+ const char *sect_name, size_t sect_size)
{
- if (which == 0)
+ struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
+ if (strcmp (sect_name, ".reg") == 0)
{
- if (core_reg_size == ELF_GREGSET_SIZE)
- ppc_linux_supply_gregset (core_reg_sect);
+ if (tdep->wordsize == 4)
+ return &ppc32_linux_gregset;
else
- warning ("wrong size gregset struct in core file");
- }
- else if (which == 2)
- {
- if (core_reg_size == ELF_FPREGSET_SIZE)
- ppc_linux_supply_fpregset (core_reg_sect);
- else
- warning ("wrong size fpregset struct in core file");
+ return &ppc64_linux_gregset;
}
+ if (strcmp (sect_name, ".reg2") == 0)
+ return &ppc_linux_fpregset;
+ return NULL;
}
-/* Register that we are able to handle ELF file formats using standard
- procfs "regset" structures. */
-
-static struct core_fns ppc_linux_regset_core_fns =
-{
- bfd_target_elf_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
-
static void
ppc_linux_init_abi (struct gdbarch_info info,
struct gdbarch *gdbarch)
@@ -1086,6 +1119,7 @@
/* PPC64 malloc's entry-point is called ".malloc". */
set_gdbarch_name_of_malloc (gdbarch, ".malloc");
}
+ set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
}
void
@@ -1099,5 +1133,4 @@
ppc_linux_init_abi);
gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
ppc_linux_init_abi);
- add_core_fns (&ppc_linux_regset_core_fns);
}
Index: ppc-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/ppc-tdep.h,v
retrieving revision 1.25
diff -u -r1.25 ppc-tdep.h
--- ppc-tdep.h 10 Nov 2003 22:47:28 -0000 1.25
+++ ppc-tdep.h 15 Mar 2004 21:28:31 -0000
@@ -1,6 +1,7 @@
/* Target-dependent code for GDB, the GNU debugger.
- Copyright 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
+ Inc.
This file is part of GDB.
@@ -62,8 +63,12 @@
CORE_ADDR bpaddr);
int ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache);
struct link_map_offsets *ppc_linux_svr4_fetch_link_map_offsets (void);
-void ppc_linux_supply_gregset (char *buf);
-void ppc_linux_supply_fpregset (char *buf);
+void ppc_linux_supply_gregset (struct regcache *regcache,
+ int regnum, const void *gregs, size_t size,
+ 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,
struct type *valtype,
2004-03-15 21:35:25 +00:00
|
|
|
bfd_byte *fpp = (void *) fpregsetp;
|
2000-09-18 01:08:24 +00:00
|
|
|
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
if (ppc_floating_point_unit_p (current_gdbarch))
|
2000-09-18 01:08:24 +00:00
|
|
|
{
|
* ppc-tdep.h (struct gdbarch_tdep): Change definition of
ppc_fp0_regnum and ppc_fpscr_regnum: if they are -1, then this
processor variant lacks those registers.
(ppc_floating_point_unit_p): Change description to make it clear
that this returns info about the ISA, not the ABI.
* rs6000-tdep.c (ppc_floating_point_unit_p): Decide whether to
return true or false by checking tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum. The original code replicated the BFD
arch/mach switching done in rs6000_gdbarch_init; it's better to
keep that logic there, and just check the results here.
(rs6000_gdbarch_init): On the E500, set tdep->ppc_fp0_regnum and
tdep->ppc_fpscr_regnum to -1 to indicate that we have no
floating-point registers.
(ppc_supply_fpregset, ppc_collect_fpregset)
(rs6000_push_dummy_call, rs6000_extract_return_value)
(rs6000_store_return_value): Assert that we have floating-point
registers.
(rs6000_dwarf2_stab_reg_to_regnum): Add FIXME.
(rs6000_frame_cache): Don't note the locations at which
floating-point registers were saved if we have no fprs.
* aix-thread.c (supply_fprs, fill_fprs): Assert that we have FP
registers.
(fetch_regs_user_thread, fetch_regs_kernel_thread)
(store_regs_user_thread, store_regs_kernel_thread): Only call
supply_fprs / fill_fprs if we actually have floating-point
registers.
(special_register_p): Check ppc_fpscr_regnum before matching
against it.
(supply_sprs64, supply_sprs32, fill_sprs64, fill_sprs32): Don't
supply / collect fpscr if we don't have it.
* ppc-bdm.c: #include "gdb_assert.h".
(bdm_ppc_fetch_registers, bdm_ppc_store_registers): Assert that we
have floating-point registers, since I can't test this code on
FP-free systems to adapt it.
* ppc-linux-nat.c (ppc_register_u_addr): Don't match against the
fpscr and floating point register numbers if they don't exist.
(fetch_register): Assert that we have floating-point registers
before we reach the code that handles them.
(store_register): Same. And use tdep instead of calling
gdbarch_tdep again.
(fill_fpregset): Don't try to collect FP registers and fpscr if we
don't have them.
(ppc_linux_sigtramp_cache): Don't record the saved locations of
fprs and fpscr if we don't have them.
(ppc_linux_supply_fpregset): Don't supply fp regs and fpscr if we
don't have them.
* ppcnbsd-nat.c: #include "gdb_assert.h".
(getfpregs_supplies): Assert that we have floating-point registers.
* ppcnbsd-tdep.c (ppcnbsd_supply_fpreg, ppcnbsd_fill_fpreg): Same.
* ppcobsd-tdep.c: #include "gdb_assert.h".
(ppcobsd_supply_gregset, ppcobsd_collect_gregset): Assert that we
have floating-point registers.
* rs6000-nat.c (regmap): Don't match against the fpscr and
floating point register numbers if they don't exist.
(fetch_inferior_registers, store_inferior_registers,
fetch_core_registers): Only fetch / store / supply the
floating-point registers and the fpscr if we have them.
* Makefile.in (ppc-bdm.o, ppc-linux-nat.o, ppcnbsd-nat.o)
(ppcobsd-tdep.o): Update dependencies.
2004-05-11 04:55:32 +00:00
|
|
|
for (regi = 0; regi < ppc_num_fprs; regi++)
|
|
|
|
{
|
|
|
|
if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
|
|
|
|
regcache_collect (tdep->ppc_fp0_regnum + regi, fpp + 8 * regi);
|
|
|
|
}
|
|
|
|
if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
|
|
|
|
right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
|
2000-09-18 01:08:24 +00:00
|
|
|
}
|
|
|
|
}
|