X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fppc-linux-nat.c;h=b5c5afb393a4d3a8eaba10510687b7d3e495ba95;hb=56be38147cbe5a85a4d2d4d9cf402696826a4392;hp=c98bb93f879f61449d0d8a9775f16a0661975d2d;hpb=a44bddec71c72898c3e5b365657a9b65fdc7ad05;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c index c98bb93f87..b5c5afb393 100644 --- a/gdb/ppc-linux-nat.c +++ b/gdb/ppc-linux-nat.c @@ -1,7 +1,7 @@ /* PPC GNU/Linux native support. - Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002, - 2003 Free Software Foundation, Inc. + Copyright (C) 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002, 2003, + 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GDB. @@ -17,8 +17,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "gdb_string.h" @@ -27,7 +27,10 @@ #include "gdbcore.h" #include "regcache.h" #include "gdb_assert.h" +#include "target.h" +#include "linux-nat.h" +#include #include #include #include @@ -42,18 +45,6 @@ #include "gregset.h" #include "ppc-tdep.h" -#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 - /* 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 @@ -79,6 +70,16 @@ #define PTRACE_SETEVRREGS 21 #endif +/* Similarly for the hardware watchpoint support. */ +#ifndef PTRACE_GET_DEBUGREG +#define PTRACE_GET_DEBUGREG 25 +#endif +#ifndef PTRACE_SET_DEBUGREG +#define PTRACE_SET_DEBUGREG 26 +#endif +#ifndef PTRACE_GETSIGINFO +#define PTRACE_GETSIGINFO 0x4202 +#endif /* 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. @@ -114,13 +115,12 @@ typedef char gdb_vrregset_t[SIZEOF_VRREGS]; /* On PPC processors that support the the Signal Processing Extension (SPE) APU, the general-purpose registers are 64 bits long. - However, the ordinary Linux kernel 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. + However, the ordinary Linux kernel PTRACE_PEEKUSER / PTRACE_POKEUSER + 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. It has unnamed raw registers that hold the upper halves @@ -144,6 +144,7 @@ struct gdb_evrregset_t error. */ int have_ptrace_getvrregs = 1; +static CORE_ADDR last_stopped_data_address = 0; /* Non-zero if our kernel may support the PTRACE_GETEVRREGS and PTRACE_SETEVRREGS requests, for reading and writing the SPE @@ -151,13 +152,6 @@ int have_ptrace_getvrregs = 1; error. */ int have_ptrace_getsetevrregs = 1; - -int -kernel_u_size (void) -{ - return (sizeof (struct user)); -} - /* *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, @@ -178,7 +172,7 @@ ppc_register_u_addr (int regno) struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); /* 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); + int wordsize = sizeof (long); /* General purpose registers occupy 1 slot each in the buffer */ if (regno >= tdep->ppc_gp0_regnum @@ -212,8 +206,19 @@ ppc_register_u_addr (int regno) u_addr = PT_MSR * wordsize; if (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum) - u_addr = PT_FPSCR * wordsize; - + { + /* NOTE: cagney/2005-02-08: On some 64-bit GNU/Linux systems the + kernel headers incorrectly contained the 32-bit definition of + PT_FPSCR. For the 32-bit definition, floating-point + registers occupy two 32-bit "slots", and the FPSCR lives in + the secondhalf of such a slot-pair (hence +1). For 64-bit, + the FPSCR instead occupies the full 64-bit 2-word-slot and + hence no adjustment is necessary. Hack around this. */ + if (wordsize == 8 && PT_FPSCR == (48 + 32 + 1)) + u_addr = (48 + 32) * wordsize; + else + u_addr = PT_FPSCR * wordsize; + } return u_addr; } @@ -221,7 +226,7 @@ ppc_register_u_addr (int regno) 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) +fetch_altivec_register (struct regcache *regcache, int tid, int regno) { int ret; int offset = 0; @@ -237,7 +242,7 @@ fetch_altivec_register (int tid, int regno) have_ptrace_getvrregs = 0; return; } - perror_with_name ("Unable to fetch AltiVec register"); + perror_with_name (_("Unable to fetch AltiVec register")); } /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes @@ -247,7 +252,7 @@ fetch_altivec_register (int tid, int regno) if (regno == (tdep->ppc_vrsave_regnum - 1)) offset = vrregsize - register_size (current_gdbarch, tdep->ppc_vrsave_regnum); - regcache_raw_supply (current_regcache, regno, + regcache_raw_supply (regcache, regno, regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset); } @@ -274,7 +279,7 @@ get_spe_registers (int tid, struct gdb_evrregset_t *evrregset) have_ptrace_getsetevrregs = 0; else /* Anything else needs to be reported. */ - perror_with_name ("Unable to fetch SPE registers"); + perror_with_name (_("Unable to fetch SPE registers")); } } @@ -286,7 +291,7 @@ get_spe_registers (int tid, struct gdb_evrregset_t *evrregset) be the number of an upper half register, acc, spefscr, or -1 to supply the values of all registers. */ static void -fetch_spe_register (int tid, int regno) +fetch_spe_register (struct regcache *regcache, int tid, int regno) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdb_evrregset_t evrregs; @@ -305,26 +310,26 @@ fetch_spe_register (int tid, int regno) int i; for (i = 0; i < ppc_num_gprs; i++) - regcache_raw_supply (current_regcache, tdep->ppc_ev0_upper_regnum + i, + regcache_raw_supply (regcache, tdep->ppc_ev0_upper_regnum + i, &evrregs.evr[i]); } else if (tdep->ppc_ev0_upper_regnum <= regno && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs) - regcache_raw_supply (current_regcache, regno, + regcache_raw_supply (regcache, regno, &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); if (regno == -1 || regno == tdep->ppc_acc_regnum) - regcache_raw_supply (current_regcache, tdep->ppc_acc_regnum, &evrregs.acc); + regcache_raw_supply (regcache, tdep->ppc_acc_regnum, &evrregs.acc); if (regno == -1 || regno == tdep->ppc_spefscr_regnum) - regcache_raw_supply (current_regcache, tdep->ppc_spefscr_regnum, + regcache_raw_supply (regcache, tdep->ppc_spefscr_regnum, &evrregs.spefscr); } static void -fetch_register (int tid, int regno) +fetch_register (struct regcache *regcache, int tid, int regno) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); /* This isn't really an address. But ptrace thinks of it as one. */ @@ -341,7 +346,7 @@ fetch_register (int tid, int regno) register. */ if (have_ptrace_getvrregs) { - fetch_altivec_register (tid, regno); + fetch_altivec_register (regcache, tid, regno); return; } /* If we have discovered that there is no ptrace support for @@ -350,28 +355,28 @@ fetch_register (int tid, int regno) } else if (spe_register_p (regno)) { - fetch_spe_register (tid, regno); + fetch_spe_register (regcache, tid, regno); return; } if (regaddr == -1) { memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */ - regcache_raw_supply (current_regcache, regno, buf); + regcache_raw_supply (regcache, regno, buf); return; } - /* Read the raw register using PTRACE_XFER_TYPE sized chunks. On a + /* Read the raw register using sizeof(long) sized chunks. On a 32-bit platform, 64-bit floating-point registers will require two transfers. */ for (bytes_transferred = 0; bytes_transferred < register_size (current_gdbarch, regno); - bytes_transferred += sizeof (PTRACE_XFER_TYPE)) + bytes_transferred += sizeof (long)) { errno = 0; - *(PTRACE_XFER_TYPE *) & buf[bytes_transferred] - = ptrace (PT_READ_U, tid, (PTRACE_ARG3_TYPE) regaddr, 0); - regaddr += sizeof (PTRACE_XFER_TYPE); + *(long *) &buf[bytes_transferred] + = ptrace (PTRACE_PEEKUSER, tid, (PTRACE_TYPE_ARG3) regaddr, 0); + regaddr += sizeof (long); if (errno != 0) { char message[128]; @@ -383,12 +388,12 @@ fetch_register (int tid, int regno) /* 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). */ + (long). */ 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); + regcache_raw_supply (regcache, regno, buf); } else if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { @@ -396,16 +401,16 @@ fetch_register (int tid, int regno) transferred. */ size_t padding = (bytes_transferred - register_size (current_gdbarch, regno)); - regcache_raw_supply (current_regcache, regno, buf + padding); + regcache_raw_supply (regcache, regno, buf + padding); } else internal_error (__FILE__, __LINE__, - "fetch_register: unexpected byte order: %d", + _("fetch_register: unexpected byte order: %d"), gdbarch_byte_order (current_gdbarch)); } static void -supply_vrregset (gdb_vrregset_t *vrregsetp) +supply_vrregset (struct regcache *regcache, gdb_vrregset_t *vrregsetp) { int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -420,16 +425,16 @@ supply_vrregset (gdb_vrregset_t *vrregsetp) occupies a whole vector, while VRSAVE occupies a full 4 bytes slot. */ if (i == (num_of_vrregs - 2)) - regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i, + regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize + offset); else - regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i, + regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize); } } static void -fetch_altivec_registers (int tid) +fetch_altivec_registers (struct regcache *regcache, int tid) { int ret; gdb_vrregset_t regs; @@ -442,49 +447,49 @@ fetch_altivec_registers (int tid) have_ptrace_getvrregs = 0; return; } - perror_with_name ("Unable to fetch AltiVec registers"); + perror_with_name (_("Unable to fetch AltiVec registers")); } - supply_vrregset (®s); + supply_vrregset (regcache, ®s); } static void -fetch_ppc_registers (int tid) +fetch_ppc_registers (struct regcache *regcache, int tid) { int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); for (i = 0; i < ppc_num_gprs; i++) - fetch_register (tid, tdep->ppc_gp0_regnum + i); + fetch_register (regcache, tid, tdep->ppc_gp0_regnum + i); 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); + fetch_register (regcache, tid, tdep->ppc_fp0_regnum + i); + fetch_register (regcache, tid, PC_REGNUM); if (tdep->ppc_ps_regnum != -1) - fetch_register (tid, tdep->ppc_ps_regnum); + fetch_register (regcache, tid, tdep->ppc_ps_regnum); if (tdep->ppc_cr_regnum != -1) - fetch_register (tid, tdep->ppc_cr_regnum); + fetch_register (regcache, tid, tdep->ppc_cr_regnum); if (tdep->ppc_lr_regnum != -1) - fetch_register (tid, tdep->ppc_lr_regnum); + fetch_register (regcache, tid, tdep->ppc_lr_regnum); if (tdep->ppc_ctr_regnum != -1) - fetch_register (tid, tdep->ppc_ctr_regnum); + fetch_register (regcache, tid, tdep->ppc_ctr_regnum); if (tdep->ppc_xer_regnum != -1) - fetch_register (tid, tdep->ppc_xer_regnum); + fetch_register (regcache, tid, tdep->ppc_xer_regnum); if (tdep->ppc_mq_regnum != -1) - fetch_register (tid, tdep->ppc_mq_regnum); + fetch_register (regcache, tid, tdep->ppc_mq_regnum); if (tdep->ppc_fpscr_regnum != -1) - fetch_register (tid, tdep->ppc_fpscr_regnum); + fetch_register (regcache, tid, tdep->ppc_fpscr_regnum); if (have_ptrace_getvrregs) if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) - fetch_altivec_registers (tid); + fetch_altivec_registers (regcache, tid); if (tdep->ppc_ev0_upper_regnum >= 0) - fetch_spe_register (tid, -1); + fetch_spe_register (regcache, tid, -1); } /* 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) +static void +ppc_linux_fetch_inferior_registers (struct regcache *regcache, int regno) { /* Overload thread id onto process id */ int tid = TIDGET (inferior_ptid); @@ -494,14 +499,14 @@ fetch_inferior_registers (int regno) tid = PIDGET (inferior_ptid); if (regno == -1) - fetch_ppc_registers (tid); + fetch_ppc_registers (regcache, tid); else - fetch_register (tid, regno); + fetch_register (regcache, tid, regno); } /* Store one register. */ static void -store_altivec_register (int tid, int regno) +store_altivec_register (const struct regcache *regcache, int tid, int regno) { int ret; int offset = 0; @@ -517,7 +522,7 @@ store_altivec_register (int tid, int regno) have_ptrace_getvrregs = 0; return; } - perror_with_name ("Unable to fetch AltiVec register"); + perror_with_name (_("Unable to fetch AltiVec register")); } /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes @@ -525,12 +530,12 @@ store_altivec_register (int tid, int regno) if (regno == (tdep->ppc_vrsave_regnum - 1)) offset = vrregsize - register_size (current_gdbarch, tdep->ppc_vrsave_regnum); - regcache_raw_collect (current_regcache, regno, + regcache_raw_collect (regcache, 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"); + perror_with_name (_("Unable to store AltiVec register")); } /* Assuming TID referrs to an SPE process, set the top halves of TID's @@ -557,7 +562,7 @@ set_spe_registers (int tid, struct gdb_evrregset_t *evrregset) have_ptrace_getsetevrregs = 0; else /* Anything else needs to be reported. */ - perror_with_name ("Unable to set SPE registers"); + perror_with_name (_("Unable to set SPE registers")); } } } @@ -566,7 +571,7 @@ set_spe_registers (int tid, struct gdb_evrregset_t *evrregset) If REGNO is -1, write the values of all the SPE-specific registers. */ static void -store_spe_register (int tid, int regno) +store_spe_register (const struct regcache *regcache, int tid, int regno) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdb_evrregset_t evrregs; @@ -594,24 +599,24 @@ store_spe_register (int tid, int regno) int i; for (i = 0; i < ppc_num_gprs; i++) - regcache_raw_collect (current_regcache, + regcache_raw_collect (regcache, tdep->ppc_ev0_upper_regnum + i, &evrregs.evr[i]); } else if (tdep->ppc_ev0_upper_regnum <= regno && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs) - regcache_raw_collect (current_regcache, regno, + regcache_raw_collect (regcache, regno, &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); if (regno == -1 || regno == tdep->ppc_acc_regnum) - regcache_raw_collect (current_regcache, + regcache_raw_collect (regcache, tdep->ppc_acc_regnum, &evrregs.acc); if (regno == -1 || regno == tdep->ppc_spefscr_regnum) - regcache_raw_collect (current_regcache, + regcache_raw_collect (regcache, tdep->ppc_spefscr_regnum, &evrregs.spefscr); @@ -620,7 +625,7 @@ store_spe_register (int tid, int regno) } static void -store_register (int tid, int regno) +store_register (const struct regcache *regcache, int tid, int regno) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); /* This isn't really an address. But ptrace thinks of it as one. */ @@ -631,12 +636,12 @@ store_register (int tid, int regno) if (altivec_register_p (regno)) { - store_altivec_register (tid, regno); + store_altivec_register (regcache, tid, regno); return; } else if (spe_register_p (regno)) { - store_spe_register (tid, regno); + store_spe_register (regcache, tid, regno); return; } @@ -645,29 +650,29 @@ store_register (int tid, int regno) /* 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). */ + (long). */ memset (buf, 0, sizeof buf); bytes_to_transfer = align_up (register_size (current_gdbarch, regno), - sizeof (PTRACE_XFER_TYPE)); + sizeof (long)); 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); + regcache_raw_collect (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); + regcache_raw_collect (regcache, regno, buf + padding); } - for (i = 0; i < bytes_to_transfer; i += sizeof (PTRACE_XFER_TYPE)) + for (i = 0; i < bytes_to_transfer; i += sizeof (long)) { errno = 0; - ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, - *(PTRACE_XFER_TYPE *) & buf[i]); - regaddr += sizeof (PTRACE_XFER_TYPE); + ptrace (PTRACE_POKEUSER, tid, (PTRACE_TYPE_ARG3) regaddr, + *(long *) &buf[i]); + regaddr += sizeof (long); if (errno == EIO && regno == tdep->ppc_fpscr_regnum) @@ -687,7 +692,7 @@ store_register (int tid, int regno) } static void -fill_vrregset (gdb_vrregset_t *vrregsetp) +fill_vrregset (const struct regcache *regcache, gdb_vrregset_t *vrregsetp) { int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -700,16 +705,16 @@ fill_vrregset (gdb_vrregset_t *vrregsetp) /* 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_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i, + regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize + offset); else - regcache_raw_collect (current_regcache, tdep->ppc_vr0_regnum + i, + regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize); } } static void -store_altivec_registers (int tid) +store_altivec_registers (const struct regcache *regcache, int tid) { int ret; gdb_vrregset_t regs; @@ -722,50 +727,168 @@ store_altivec_registers (int tid) have_ptrace_getvrregs = 0; return; } - perror_with_name ("Couldn't get AltiVec registers"); + perror_with_name (_("Couldn't get AltiVec registers")); } - fill_vrregset (®s); + fill_vrregset (regcache, ®s); if (ptrace (PTRACE_SETVRREGS, tid, 0, ®s) < 0) - perror_with_name ("Couldn't write AltiVec registers"); + perror_with_name (_("Couldn't write AltiVec registers")); } static void -store_ppc_registers (int tid) +store_ppc_registers (const struct regcache *regcache, int tid) { int i; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); for (i = 0; i < ppc_num_gprs; i++) - store_register (tid, tdep->ppc_gp0_regnum + i); + store_register (regcache, tid, tdep->ppc_gp0_regnum + i); 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); + store_register (regcache, tid, tdep->ppc_fp0_regnum + i); + store_register (regcache, tid, PC_REGNUM); if (tdep->ppc_ps_regnum != -1) - store_register (tid, tdep->ppc_ps_regnum); + store_register (regcache, tid, tdep->ppc_ps_regnum); if (tdep->ppc_cr_regnum != -1) - store_register (tid, tdep->ppc_cr_regnum); + store_register (regcache, tid, tdep->ppc_cr_regnum); if (tdep->ppc_lr_regnum != -1) - store_register (tid, tdep->ppc_lr_regnum); + store_register (regcache, tid, tdep->ppc_lr_regnum); if (tdep->ppc_ctr_regnum != -1) - store_register (tid, tdep->ppc_ctr_regnum); + store_register (regcache, tid, tdep->ppc_ctr_regnum); if (tdep->ppc_xer_regnum != -1) - store_register (tid, tdep->ppc_xer_regnum); + store_register (regcache, tid, tdep->ppc_xer_regnum); if (tdep->ppc_mq_regnum != -1) - store_register (tid, tdep->ppc_mq_regnum); + store_register (regcache, tid, tdep->ppc_mq_regnum); if (tdep->ppc_fpscr_regnum != -1) - store_register (tid, tdep->ppc_fpscr_regnum); + store_register (regcache, tid, tdep->ppc_fpscr_regnum); if (have_ptrace_getvrregs) if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) - store_altivec_registers (tid); + store_altivec_registers (regcache, tid); if (tdep->ppc_ev0_upper_regnum >= 0) - store_spe_register (tid, -1); + store_spe_register (regcache, tid, -1); } -void -store_inferior_registers (int regno) +static int +ppc_linux_check_watch_resources (int type, int cnt, int ot) +{ + int tid; + ptid_t ptid = inferior_ptid; + + /* DABR (data address breakpoint register) is optional for PPC variants. + Some variants have one DABR, others have none. So CNT can't be larger + than 1. */ + if (cnt > 1) + return 0; + + /* We need to know whether ptrace supports PTRACE_SET_DEBUGREG and whether + the target has DABR. If either answer is no, the ptrace call will + return -1. Fail in that case. */ + tid = TIDGET (ptid); + if (tid == 0) + tid = PIDGET (ptid); + + if (ptrace (PTRACE_SET_DEBUGREG, tid, 0, 0) == -1) + return 0; + return 1; +} + +static int +ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) +{ + /* Handle sub-8-byte quantities. */ + if (len <= 0) + return 0; + + /* addr+len must fall in the 8 byte watchable region. */ + if ((addr + len) > (addr & ~7) + 8) + return 0; + + return 1; +} + +/* Set a watchpoint of type TYPE at address ADDR. */ +static int +ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw) +{ + int tid; + long dabr_value; + ptid_t ptid = inferior_ptid; + + dabr_value = addr & ~7; + switch (rw) + { + case hw_read: + /* Set read and translate bits. */ + dabr_value |= 5; + break; + case hw_write: + /* Set write and translate bits. */ + dabr_value |= 6; + break; + case hw_access: + /* Set read, write and translate bits. */ + dabr_value |= 7; + break; + } + + tid = TIDGET (ptid); + if (tid == 0) + tid = PIDGET (ptid); + + return ptrace (PTRACE_SET_DEBUGREG, tid, 0, dabr_value); +} + +static int +ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw) +{ + int tid; + ptid_t ptid = inferior_ptid; + + tid = TIDGET (ptid); + if (tid == 0) + tid = PIDGET (ptid); + + return ptrace (PTRACE_SET_DEBUGREG, tid, 0, 0); +} + +static int +ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) +{ + if (last_stopped_data_address) + { + *addr_p = last_stopped_data_address; + last_stopped_data_address = 0; + return 1; + } + return 0; +} + +static int +ppc_linux_stopped_by_watchpoint (void) +{ + int tid; + struct siginfo siginfo; + ptid_t ptid = inferior_ptid; + CORE_ADDR *addr_p; + + tid = TIDGET(ptid); + if (tid == 0) + tid = PIDGET (ptid); + + errno = 0; + ptrace (PTRACE_GETSIGINFO, tid, (PTRACE_TYPE_ARG3) 0, &siginfo); + + if (errno != 0 || siginfo.si_signo != SIGTRAP || + (siginfo.si_code & 0xffff) != 0x0004) + return 0; + + last_stopped_data_address = (uintptr_t) siginfo.si_addr; + return 1; +} + +static void +ppc_linux_store_inferior_registers (struct regcache *regcache, int regno) { /* Overload thread id onto process id */ int tid = TIDGET (inferior_ptid); @@ -775,36 +898,37 @@ store_inferior_registers (int regno) tid = PIDGET (inferior_ptid); if (regno >= 0) - store_register (tid, regno); + store_register (regcache, tid, regno); else - store_ppc_registers (tid); + store_ppc_registers (regcache, tid); } void -supply_gregset (gdb_gregset_t *gregsetp) +supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) { /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace interface, and not the wordsize of the program's ABI. */ - int wordsize = sizeof (PTRACE_XFER_TYPE); - ppc_linux_supply_gregset (current_regcache, -1, gregsetp, + int wordsize = sizeof (long); + ppc_linux_supply_gregset (regcache, -1, gregsetp, sizeof (gdb_gregset_t), wordsize); } static void -right_fill_reg (int regnum, void *reg) +right_fill_reg (const struct regcache *regcache, int regnum, void *reg) { /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace interface, and not the wordsize of the program's ABI. */ - int wordsize = sizeof (PTRACE_XFER_TYPE); + int wordsize = sizeof (long); /* Right fill the register. */ - regcache_raw_collect (current_regcache, regnum, + regcache_raw_collect (regcache, regnum, ((bfd_byte *) reg + wordsize - register_size (current_gdbarch, regnum))); } void -fill_gregset (gdb_gregset_t *gregsetp, int regno) +fill_gregset (const struct regcache *regcache, + gdb_gregset_t *gregsetp, int regno) { int regi; elf_greg_t *regp = (elf_greg_t *) gregsetp; @@ -818,34 +942,35 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno) for (regi = 0; regi < ppc_num_gprs; regi++) { if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi) - right_fill_reg (tdep->ppc_gp0_regnum + regi, (regp + PT_R0 + regi)); + right_fill_reg (regcache, tdep->ppc_gp0_regnum + regi, + (regp + PT_R0 + regi)); } if ((regno == -1) || regno == PC_REGNUM) - right_fill_reg (PC_REGNUM, regp + PT_NIP); + right_fill_reg (regcache, PC_REGNUM, regp + PT_NIP); if ((regno == -1) || regno == tdep->ppc_lr_regnum) - right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK); + right_fill_reg (regcache, tdep->ppc_lr_regnum, regp + PT_LNK); if ((regno == -1) || regno == tdep->ppc_cr_regnum) - regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, + regcache_raw_collect (regcache, tdep->ppc_cr_regnum, regp + PT_CCR); if ((regno == -1) || regno == tdep->ppc_xer_regnum) - regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, + regcache_raw_collect (regcache, tdep->ppc_xer_regnum, regp + PT_XER); if ((regno == -1) || regno == tdep->ppc_ctr_regnum) - right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR); + right_fill_reg (regcache, tdep->ppc_ctr_regnum, regp + PT_CTR); #ifdef PT_MQ if (((regno == -1) || regno == tdep->ppc_mq_regnum) && (tdep->ppc_mq_regnum != -1)) - right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ); + right_fill_reg (regcache, tdep->ppc_mq_regnum, regp + PT_MQ); #endif if ((regno == -1) || regno == tdep->ppc_ps_regnum) - right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR); + right_fill_reg (regcache, tdep->ppc_ps_regnum, regp + PT_MSR); } void -supply_fpregset (gdb_fpregset_t * fpregsetp) +supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp) { - ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp, + ppc_linux_supply_fpregset (NULL, regcache, -1, fpregsetp, sizeof (gdb_fpregset_t)); } @@ -854,7 +979,8 @@ supply_fpregset (gdb_fpregset_t * fpregsetp) idea of the current floating point register set. If REGNO is -1, update them all. */ void -fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) +fill_fpregset (const struct regcache *regcache, + gdb_fpregset_t *fpregsetp, int regno) { int regi; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); @@ -865,10 +991,36 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) for (regi = 0; regi < ppc_num_fprs; regi++) { if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi)) - regcache_raw_collect (current_regcache, tdep->ppc_fp0_regnum + regi, + regcache_raw_collect (regcache, tdep->ppc_fp0_regnum + regi, fpp + 8 * regi); } if (regno == -1 || regno == tdep->ppc_fpscr_regnum) - right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32)); + right_fill_reg (regcache, tdep->ppc_fpscr_regnum, (fpp + 8 * 32)); } } + +void _initialize_ppc_linux_nat (void); + +void +_initialize_ppc_linux_nat (void) +{ + struct target_ops *t; + + /* Fill in the generic GNU/Linux methods. */ + t = linux_target (); + + /* Add our register access methods. */ + t->to_fetch_registers = ppc_linux_fetch_inferior_registers; + t->to_store_registers = ppc_linux_store_inferior_registers; + + /* Add our watchpoint methods. */ + t->to_can_use_hw_breakpoint = ppc_linux_check_watch_resources; + t->to_region_ok_for_hw_watchpoint = ppc_linux_region_ok_for_hw_watchpoint; + t->to_insert_watchpoint = ppc_linux_insert_watchpoint; + t->to_remove_watchpoint = ppc_linux_remove_watchpoint; + t->to_stopped_by_watchpoint = ppc_linux_stopped_by_watchpoint; + t->to_stopped_data_address = ppc_linux_stopped_data_address; + + /* Register the target. */ + linux_nat_add_target (t); +}