X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fppc-linux-nat.c;h=d619971a001d225ea278c776e09fb5297074c6a7;hb=735fc2ca685b55bf1debbfcea6d2ab544e58a530;hp=ef94a48bd24f9218fe73a05fbe305f5af22dcec4;hpb=f5656eadf4383cc733b96ff49ba8efbea6922ad3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c index ef94a48bd2..d619971a00 100644 --- a/gdb/ppc-linux-nat.c +++ b/gdb/ppc-linux-nat.c @@ -1,7 +1,6 @@ /* PPC GNU/Linux native support. - Copyright (C) 1988-1989, 1991-1992, 1994, 1996, 2000-2012 Free - Software Foundation, Inc. + Copyright (C) 1988-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -19,27 +18,26 @@ along with this program. If not, see . */ #include "defs.h" -#include "gdb_string.h" -#include "observer.h" +#include "observable.h" #include "frame.h" #include "inferior.h" #include "gdbthread.h" #include "gdbcore.h" #include "regcache.h" -#include "gdb_assert.h" +#include "regset.h" #include "target.h" #include "linux-nat.h" - -#include #include -#include #include #include #include -#include "gdb_wait.h" +#include +#include "gdbsupport/gdb_wait.h" #include #include -#include +#include "nat/gdb_ptrace.h" +#include "nat/linux-ptrace.h" +#include "inf-ptrace.h" /* Prototypes for supply_gregset etc. */ #include "gregset.h" @@ -50,60 +48,13 @@ #include "elf/common.h" #include "auxv.h" -/* This sometimes isn't defined. */ -#ifndef PT_ORIG_R3 -#define PT_ORIG_R3 34 -#endif -#ifndef PT_TRAP -#define PT_TRAP 40 -#endif - -/* The PPC_FEATURE_* defines should be provided by . - If they aren't, we can provide them ourselves (their values are fixed - because they are part of the kernel ABI). They are used in the AT_HWCAP - entry of the AUXV. */ -#ifndef PPC_FEATURE_CELL -#define PPC_FEATURE_CELL 0x00010000 -#endif -#ifndef PPC_FEATURE_BOOKE -#define PPC_FEATURE_BOOKE 0x00008000 -#endif -#ifndef PPC_FEATURE_HAS_DFP -#define PPC_FEATURE_HAS_DFP 0x00000400 /* Decimal Floating Point. */ -#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 - 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 - -/* PTRACE requests for POWER7 VSX registers. */ -#ifndef PTRACE_GETVSXREGS -#define PTRACE_GETVSXREGS 27 -#define PTRACE_SETVSXREGS 28 -#endif - -/* 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 +#include "arch/ppc-linux-common.h" +#include "arch/ppc-linux-tdesc.h" +#include "nat/ppc-linux.h" +#include "linux-tdep.h" /* Similarly for the hardware watchpoint support. These requests are used - when the BookE kernel interface is not available. */ + when the PowerPC HWDEBUG ptrace interface is not available. */ #ifndef PTRACE_GET_DEBUGREG #define PTRACE_GET_DEBUGREG 25 #endif @@ -114,15 +65,15 @@ #define PTRACE_GETSIGINFO 0x4202 #endif -/* These requests are used when the BookE kernel interface is available. - It exposes the additional debug features of BookE processors, such as - ranged breakpoints and watchpoints and hardware-accelerated condition - evaluation. */ +/* These requests are used when the PowerPC HWDEBUG ptrace interface is + available. It exposes the debug facilities of PowerPC processors, as well + as additional features of BookE processors, such as ranged breakpoints and + watchpoints and hardware-accelerated condition evaluation. */ #ifndef PPC_PTRACE_GETHWDBGINFO -/* Not having PPC_PTRACE_GETHWDBGINFO defined means that the new BookE - interface is not present in ptrace.h, so we'll have to pretty much include - it all here so that the code at least compiles on older systems. */ +/* Not having PPC_PTRACE_GETHWDBGINFO defined means that the PowerPC HWDEBUG + ptrace interface is not present in ptrace.h, so we'll have to pretty much + include it all here so that the code at least compiles on older systems. */ #define PPC_PTRACE_GETHWDBGINFO 0x89 #define PPC_PTRACE_SETHWDEBUG 0x88 #define PPC_PTRACE_DELHWDEBUG 0x87 @@ -179,7 +130,11 @@ struct ppc_hw_breakpoint (1<<((n)+PPC_BREAKPOINT_CONDITION_BE_SHIFT)) #endif /* PPC_PTRACE_GETHWDBGINFO */ - +/* Feature defined on Linux kernel v3.9: DAWR interface, that enables wider + watchpoint (up to 512 bytes). */ +#ifndef PPC_DEBUG_FEATURE_DATA_BP_DAWR +#define PPC_DEBUG_FEATURE_DATA_BP_DAWR 0x10 +#endif /* PPC_DEBUG_FEATURE_DATA_BP_DAWR */ /* Similarly for the general-purpose (gp0 -- gp31) and floating-point registers (fp0 -- fp31). */ @@ -209,23 +164,22 @@ struct ppc_hw_breakpoint 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* */ /* +Big-Endian: |.|.|.|.|.....|.|.|.|.||.|.|.|x||.| <-------> <-------><-------><-> VR0 VR31 VSCR VRSAVE +Little-Endian: + |.|.|.|.|.....|.|.|.|.||X|.|.|.||.| + <-------> <-------><-------><-> + VR0 VR31 VSCR VRSAVE */ /* *INDENT-ON* */ -#define SIZEOF_VRREGS 33*16+4 - -typedef char gdb_vrregset_t[SIZEOF_VRREGS]; +typedef char gdb_vrregset_t[PPC_LINUX_SIZEOF_VRREGSET]; /* This is the layout of the POWER7 VSX registers and the way they overlap with the existing FPR and VMX registers. @@ -259,9 +213,7 @@ typedef char gdb_vrregset_t[SIZEOF_VRREGS]; the FP registers (doubleword 0) and hence extend them with additional 64 bits (doubleword 1). The other 32 regs overlap with the VMX registers. */ -#define SIZEOF_VSXREGS 32*8 - -typedef char gdb_vsxregset_t[SIZEOF_VSXREGS]; +typedef char gdb_vsxregset_t[PPC_LINUX_SIZEOF_VSXREGSET]; /* On PPC processors that support the Signal Processing Extension (SPE) APU, the general-purpose registers are 64 bits long. @@ -318,6 +270,60 @@ int have_ptrace_getsetregs = 1; them and gotten an error. */ int have_ptrace_getsetfpregs = 1; +struct ppc_linux_nat_target final : public linux_nat_target +{ + /* Add our register access methods. */ + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + /* Add our breakpoint/watchpoint methods. */ + int can_use_hw_breakpoint (enum bptype, int, int) override; + + int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) + override; + + int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) + override; + + int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; + + int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, + struct expression *) override; + + int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, + struct expression *) override; + + int insert_mask_watchpoint (CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) + override; + + int remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) + override; + + bool stopped_by_watchpoint () override; + + bool stopped_data_address (CORE_ADDR *) override; + + bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override; + + bool can_accel_watchpoint_condition (CORE_ADDR, int, int, struct expression *) + override; + + int masked_watch_num_registers (CORE_ADDR, CORE_ADDR) override; + + int ranged_break_num_registers () override; + + const struct target_desc *read_description () override; + + int auxv_parse (gdb_byte **readptr, + gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) + override; + + /* Override linux_nat_target low methods. */ + void low_new_thread (struct lwp_info *lp) override; +}; + +static ppc_linux_nat_target the_ppc_linux_nat_target; + /* *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, @@ -406,13 +412,11 @@ ppc_register_u_addr (struct gdbarch *gdbarch, int regno) registers set mechanism, as opposed to the interface for all the other registers, that stores/fetches each register individually. */ static void -fetch_vsx_register (struct regcache *regcache, int tid, int regno) +fetch_vsx_registers (struct regcache *regcache, int tid, int regno) { int ret; gdb_vsxregset_t regs; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vsxregsize = register_size (gdbarch, tdep->ppc_vsr0_upper_regnum); + const struct regset *vsxregset = ppc_linux_vsxregset (); ret = ptrace (PTRACE_GETVSXREGS, tid, 0, ®s); if (ret < 0) @@ -422,26 +426,24 @@ fetch_vsx_register (struct regcache *regcache, int tid, int regno) have_ptrace_getsetvsxregs = 0; return; } - perror_with_name (_("Unable to fetch VSX register")); + perror_with_name (_("Unable to fetch VSX registers")); } - regcache_raw_supply (regcache, regno, - regs + (regno - tdep->ppc_vsr0_upper_regnum) - * vsxregsize); + vsxregset->supply_regset (vsxregset, regcache, regno, ®s, + PPC_LINUX_SIZEOF_VSXREGSET); } /* 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 (struct regcache *regcache, int tid, int regno) +fetch_altivec_registers (struct regcache *regcache, int tid, + int regno) { int ret; - int offset = 0; gdb_vrregset_t regs; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum); + struct gdbarch *gdbarch = regcache->arch (); + const struct regset *vrregset = ppc_linux_vrregset (gdbarch); ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); if (ret < 0) @@ -451,19 +453,11 @@ fetch_altivec_register (struct regcache *regcache, int tid, int regno) have_ptrace_getvrregs = 0; return; } - perror_with_name (_("Unable to fetch AltiVec register")); + perror_with_name (_("Unable to fetch AltiVec registers")); } - - /* 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)) - offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum); - - regcache_raw_supply (regcache, regno, - regs + (regno - - tdep->ppc_vr0_regnum) * vrregsize + offset); + + vrregset->supply_regset (vrregset, regcache, regno, ®s, + PPC_LINUX_SIZEOF_VRREGSET); } /* Fetch the top 32 bits of TID's general-purpose registers and the @@ -503,7 +497,7 @@ get_spe_registers (int tid, struct gdb_evrregset_t *evrregset) static void fetch_spe_register (struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdb_evrregset_t evrregs; @@ -521,55 +515,124 @@ fetch_spe_register (struct regcache *regcache, int tid, int regno) int i; for (i = 0; i < ppc_num_gprs; i++) - regcache_raw_supply (regcache, tdep->ppc_ev0_upper_regnum + i, - &evrregs.evr[i]); + regcache->raw_supply (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 (regcache, regno, - &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); + regcache->raw_supply (regno, + &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); if (regno == -1 || regno == tdep->ppc_acc_regnum) - regcache_raw_supply (regcache, tdep->ppc_acc_regnum, &evrregs.acc); + regcache->raw_supply (tdep->ppc_acc_regnum, &evrregs.acc); if (regno == -1 || regno == tdep->ppc_spefscr_regnum) - regcache_raw_supply (regcache, tdep->ppc_spefscr_regnum, - &evrregs.spefscr); + regcache->raw_supply (tdep->ppc_spefscr_regnum, &evrregs.spefscr); +} + +/* Use ptrace to fetch all registers from the register set with note + type REGSET_ID, size REGSIZE, and layout described by REGSET, from + process/thread TID and supply their values to REGCACHE. If ptrace + returns ENODATA to indicate the regset is unavailable, mark the + registers as unavailable in REGCACHE. */ + +static void +fetch_regset (struct regcache *regcache, int tid, + int regset_id, int regsetsize, const struct regset *regset) +{ + void *buf = alloca (regsetsize); + struct iovec iov; + + iov.iov_base = buf; + iov.iov_len = regsetsize; + + if (ptrace (PTRACE_GETREGSET, tid, regset_id, &iov) < 0) + { + if (errno == ENODATA) + regset->supply_regset (regset, regcache, -1, NULL, regsetsize); + else + perror_with_name (_("Couldn't get register set")); + } + else + regset->supply_regset (regset, regcache, -1, buf, regsetsize); +} + +/* Use ptrace to store register REGNUM of the regset with note type + REGSET_ID, size REGSETSIZE, and layout described by REGSET, from + REGCACHE back to process/thread TID. If REGNUM is -1 all registers + in the set are collected and stored. */ + +static void +store_regset (const struct regcache *regcache, int tid, int regnum, + int regset_id, int regsetsize, const struct regset *regset) +{ + void *buf = alloca (regsetsize); + struct iovec iov; + + iov.iov_base = buf; + iov.iov_len = regsetsize; + + /* Make sure that the buffer that will be stored has up to date values + for the registers that won't be collected. */ + if (ptrace (PTRACE_GETREGSET, tid, regset_id, &iov) < 0) + perror_with_name (_("Couldn't get register set")); + + regset->collect_regset (regset, regcache, regnum, buf, regsetsize); + + if (ptrace (PTRACE_SETREGSET, tid, regset_id, &iov) < 0) + perror_with_name (_("Couldn't set register set")); +} + +/* Check whether the kernel provides a register set with number + REGSET_ID of size REGSETSIZE for process/thread TID. */ + +static bool +check_regset (int tid, int regset_id, int regsetsize) +{ + void *buf = alloca (regsetsize); + struct iovec iov; + + iov.iov_base = buf; + iov.iov_len = regsetsize; + + if (ptrace (PTRACE_GETREGSET, tid, regset_id, &iov) >= 0 + || errno == ENODATA) + return true; + else + return false; } static void fetch_register (struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* This isn't really an address. But ptrace thinks of it as one. */ CORE_ADDR regaddr = ppc_register_u_addr (gdbarch, regno); int bytes_transferred; - unsigned int offset; /* Offset of registers within the u area. */ - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[PPC_MAX_REGISTER_SIZE]; if (altivec_register_p (gdbarch, 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 + time through, and we have confirmed that there is kernel support for such a ptrace request, then go and fetch the register. */ if (have_ptrace_getvrregs) { - fetch_altivec_register (regcache, tid, regno); + fetch_altivec_registers (regcache, 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. */ } - if (vsx_register_p (gdbarch, regno)) + else if (vsx_register_p (gdbarch, regno)) { if (have_ptrace_getsetvsxregs) { - fetch_vsx_register (regcache, tid, regno); + fetch_vsx_registers (regcache, tid, regno); return; } } @@ -578,11 +641,132 @@ fetch_register (struct regcache *regcache, int tid, int regno) fetch_spe_register (regcache, tid, regno); return; } + else if (regno == PPC_DSCR_REGNUM) + { + gdb_assert (tdep->ppc_dscr_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_DSCR, + PPC_LINUX_SIZEOF_DSCRREGSET, + &ppc32_linux_dscrregset); + return; + } + else if (regno == PPC_PPR_REGNUM) + { + gdb_assert (tdep->ppc_ppr_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_PPR, + PPC_LINUX_SIZEOF_PPRREGSET, + &ppc32_linux_pprregset); + return; + } + else if (regno == PPC_TAR_REGNUM) + { + gdb_assert (tdep->ppc_tar_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_TAR, + PPC_LINUX_SIZEOF_TARREGSET, + &ppc32_linux_tarregset); + return; + } + else if (PPC_IS_EBB_REGNUM (regno)) + { + gdb_assert (tdep->have_ebb); + + fetch_regset (regcache, tid, NT_PPC_EBB, + PPC_LINUX_SIZEOF_EBBREGSET, + &ppc32_linux_ebbregset); + return; + } + else if (PPC_IS_PMU_REGNUM (regno)) + { + gdb_assert (tdep->ppc_mmcr0_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_PMU, + PPC_LINUX_SIZEOF_PMUREGSET, + &ppc32_linux_pmuregset); + return; + } + else if (PPC_IS_TMSPR_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_spr); + + fetch_regset (regcache, tid, NT_PPC_TM_SPR, + PPC_LINUX_SIZEOF_TM_SPRREGSET, + &ppc32_linux_tm_sprregset); + return; + } + else if (PPC_IS_CKPTGP_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_core); + + const struct regset *cgprregset = ppc_linux_cgprregset (gdbarch); + fetch_regset (regcache, tid, NT_PPC_TM_CGPR, + (tdep->wordsize == 4? + PPC32_LINUX_SIZEOF_CGPRREGSET + : PPC64_LINUX_SIZEOF_CGPRREGSET), + cgprregset); + return; + } + else if (PPC_IS_CKPTFP_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_fpu); + + fetch_regset (regcache, tid, NT_PPC_TM_CFPR, + PPC_LINUX_SIZEOF_CFPRREGSET, + &ppc32_linux_cfprregset); + return; + } + else if (PPC_IS_CKPTVMX_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_altivec); + + const struct regset *cvmxregset = ppc_linux_cvmxregset (gdbarch); + fetch_regset (regcache, tid, NT_PPC_TM_CVMX, + PPC_LINUX_SIZEOF_CVMXREGSET, + cvmxregset); + return; + } + else if (PPC_IS_CKPTVSX_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_vsx); + + fetch_regset (regcache, tid, NT_PPC_TM_CVSX, + PPC_LINUX_SIZEOF_CVSXREGSET, + &ppc32_linux_cvsxregset); + return; + } + else if (regno == PPC_CPPR_REGNUM) + { + gdb_assert (tdep->ppc_cppr_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_TM_CPPR, + PPC_LINUX_SIZEOF_CPPRREGSET, + &ppc32_linux_cpprregset); + return; + } + else if (regno == PPC_CDSCR_REGNUM) + { + gdb_assert (tdep->ppc_cdscr_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_TM_CDSCR, + PPC_LINUX_SIZEOF_CDSCRREGSET, + &ppc32_linux_cdscrregset); + return; + } + else if (regno == PPC_CTAR_REGNUM) + { + gdb_assert (tdep->ppc_ctar_regnum != -1); + + fetch_regset (regcache, tid, NT_PPC_TM_CTAR, + PPC_LINUX_SIZEOF_CTARREGSET, + &ppc32_linux_ctarregset); + return; + } if (regaddr == -1) { memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */ - regcache_raw_supply (regcache, regno, buf); + regcache->raw_supply (regno, buf); return; } @@ -601,8 +785,8 @@ fetch_register (struct regcache *regcache, int tid, int regno) if (errno != 0) { char message[128]; - sprintf (message, "reading register %s (#%d)", - gdbarch_register_name (gdbarch, regno), regno); + xsnprintf (message, sizeof (message), "reading register %s (#%d)", + gdbarch_register_name (gdbarch, regno), regno); perror_with_name (message); } memcpy (&buf[bytes_transferred], &l, sizeof (l)); @@ -615,14 +799,14 @@ fetch_register (struct regcache *regcache, int tid, int regno) { /* Little-endian values are always found at the left end of the bytes transferred. */ - regcache_raw_supply (regcache, regno, buf); + regcache->raw_supply (regno, buf); } else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { /* Big-endian values are found at the right end of the bytes transferred. */ size_t padding = (bytes_transferred - register_size (gdbarch, regno)); - regcache_raw_supply (regcache, regno, buf + padding); + regcache->raw_supply (regno, buf + padding); } else internal_error (__FILE__, __LINE__, @@ -630,84 +814,6 @@ fetch_register (struct regcache *regcache, int tid, int regno) gdbarch_byte_order (gdbarch)); } -static void -supply_vsxregset (struct regcache *regcache, gdb_vsxregset_t *vsxregsetp) -{ - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vsxregsize = register_size (gdbarch, tdep->ppc_vsr0_upper_regnum); - - for (i = 0; i < ppc_num_vshrs; i++) - { - regcache_raw_supply (regcache, tdep->ppc_vsr0_upper_regnum + i, - *vsxregsetp + i * vsxregsize); - } -} - -static void -supply_vrregset (struct regcache *regcache, gdb_vrregset_t *vrregsetp) -{ - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; - int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum); - int offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum); - - 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)) - regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i, - *vrregsetp + i * vrregsize + offset); - else - regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i, - *vrregsetp + i * vrregsize); - } -} - -static void -fetch_vsx_registers (struct regcache *regcache, int tid) -{ - int ret; - gdb_vsxregset_t regs; - - ret = ptrace (PTRACE_GETVSXREGS, tid, 0, ®s); - if (ret < 0) - { - if (errno == EIO) - { - have_ptrace_getsetvsxregs = 0; - return; - } - perror_with_name (_("Unable to fetch VSX registers")); - } - supply_vsxregset (regcache, ®s); -} - -static void -fetch_altivec_registers (struct regcache *regcache, 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 (regcache, ®s); -} - /* This function actually issues the request to ptrace, telling it to get all general-purpose registers and put them into the specified regset. @@ -719,8 +825,6 @@ fetch_altivec_registers (struct regcache *regcache, int tid) static int fetch_all_gp_regs (struct regcache *regcache, int tid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); gdb_gregset_t gregset; if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) @@ -747,7 +851,7 @@ fetch_all_gp_regs (struct regcache *regcache, int tid) static void fetch_gp_regs (struct regcache *regcache, int tid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int i; @@ -799,7 +903,7 @@ fetch_all_fp_regs (struct regcache *regcache, int tid) static void fetch_fp_regs (struct regcache *regcache, int tid) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int i; @@ -817,8 +921,7 @@ fetch_fp_regs (struct regcache *regcache, int tid) static void fetch_ppc_registers (struct regcache *regcache, int tid) { - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); fetch_gp_regs (regcache, tid); @@ -846,27 +949,81 @@ fetch_ppc_registers (struct regcache *regcache, int tid) 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 (regcache, tid); + fetch_altivec_registers (regcache, tid, -1); if (have_ptrace_getsetvsxregs) if (tdep->ppc_vsr0_upper_regnum != -1) - fetch_vsx_registers (regcache, tid); + fetch_vsx_registers (regcache, tid, -1); if (tdep->ppc_ev0_upper_regnum >= 0) fetch_spe_register (regcache, tid, -1); + if (tdep->ppc_ppr_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_PPR, + PPC_LINUX_SIZEOF_PPRREGSET, + &ppc32_linux_pprregset); + if (tdep->ppc_dscr_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_DSCR, + PPC_LINUX_SIZEOF_DSCRREGSET, + &ppc32_linux_dscrregset); + if (tdep->ppc_tar_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_TAR, + PPC_LINUX_SIZEOF_TARREGSET, + &ppc32_linux_tarregset); + if (tdep->have_ebb) + fetch_regset (regcache, tid, NT_PPC_EBB, + PPC_LINUX_SIZEOF_EBBREGSET, + &ppc32_linux_ebbregset); + if (tdep->ppc_mmcr0_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_PMU, + PPC_LINUX_SIZEOF_PMUREGSET, + &ppc32_linux_pmuregset); + if (tdep->have_htm_spr) + fetch_regset (regcache, tid, NT_PPC_TM_SPR, + PPC_LINUX_SIZEOF_TM_SPRREGSET, + &ppc32_linux_tm_sprregset); + if (tdep->have_htm_core) + { + const struct regset *cgprregset = ppc_linux_cgprregset (gdbarch); + fetch_regset (regcache, tid, NT_PPC_TM_CGPR, + (tdep->wordsize == 4? + PPC32_LINUX_SIZEOF_CGPRREGSET + : PPC64_LINUX_SIZEOF_CGPRREGSET), + cgprregset); + } + if (tdep->have_htm_fpu) + fetch_regset (regcache, tid, NT_PPC_TM_CFPR, + PPC_LINUX_SIZEOF_CFPRREGSET, + &ppc32_linux_cfprregset); + if (tdep->have_htm_altivec) + { + const struct regset *cvmxregset = ppc_linux_cvmxregset (gdbarch); + fetch_regset (regcache, tid, NT_PPC_TM_CVMX, + PPC_LINUX_SIZEOF_CVMXREGSET, + cvmxregset); + } + if (tdep->have_htm_vsx) + fetch_regset (regcache, tid, NT_PPC_TM_CVSX, + PPC_LINUX_SIZEOF_CVSXREGSET, + &ppc32_linux_cvsxregset); + if (tdep->ppc_cppr_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_TM_CPPR, + PPC_LINUX_SIZEOF_CPPRREGSET, + &ppc32_linux_cpprregset); + if (tdep->ppc_cdscr_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_TM_CDSCR, + PPC_LINUX_SIZEOF_CDSCRREGSET, + &ppc32_linux_cdscrregset); + if (tdep->ppc_ctar_regnum != -1) + fetch_regset (regcache, tid, NT_PPC_TM_CTAR, + PPC_LINUX_SIZEOF_CTARREGSET, + &ppc32_linux_ctarregset); } /* 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. */ -static void -ppc_linux_fetch_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +ppc_linux_nat_target::fetch_registers (struct regcache *regcache, int regno) { - /* 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); + pid_t tid = get_ptrace_pid (regcache->ptid ()); if (regno == -1) fetch_ppc_registers (regcache, tid); @@ -874,15 +1031,12 @@ ppc_linux_fetch_inferior_registers (struct target_ops *ops, fetch_register (regcache, tid, regno); } -/* Store one VSX register. */ static void -store_vsx_register (const struct regcache *regcache, int tid, int regno) +store_vsx_registers (const struct regcache *regcache, int tid, int regno) { int ret; gdb_vsxregset_t regs; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vsxregsize = register_size (gdbarch, tdep->ppc_vsr0_upper_regnum); + const struct regset *vsxregset = ppc_linux_vsxregset (); ret = ptrace (PTRACE_GETVSXREGS, tid, 0, ®s); if (ret < 0) @@ -892,27 +1046,25 @@ store_vsx_register (const struct regcache *regcache, int tid, int regno) have_ptrace_getsetvsxregs = 0; return; } - perror_with_name (_("Unable to fetch VSX register")); + perror_with_name (_("Unable to fetch VSX registers")); } - regcache_raw_collect (regcache, regno, regs + - (regno - tdep->ppc_vsr0_upper_regnum) * vsxregsize); + vsxregset->collect_regset (vsxregset, regcache, regno, ®s, + PPC_LINUX_SIZEOF_VSXREGSET); ret = ptrace (PTRACE_SETVSXREGS, tid, 0, ®s); if (ret < 0) - perror_with_name (_("Unable to store VSX register")); + perror_with_name (_("Unable to store VSX registers")); } -/* Store one register. */ static void -store_altivec_register (const struct regcache *regcache, int tid, int regno) +store_altivec_registers (const struct regcache *regcache, int tid, + int regno) { int ret; - int offset = 0; gdb_vrregset_t regs; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum); + struct gdbarch *gdbarch = regcache->arch (); + const struct regset *vrregset = ppc_linux_vrregset (gdbarch); ret = ptrace (PTRACE_GETVRREGS, tid, 0, ®s); if (ret < 0) @@ -922,24 +1074,18 @@ store_altivec_register (const struct regcache *regcache, int tid, int regno) have_ptrace_getvrregs = 0; return; } - perror_with_name (_("Unable to fetch AltiVec register")); + perror_with_name (_("Unable to fetch AltiVec registers")); } - /* 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)) - offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum); - - regcache_raw_collect (regcache, regno, - regs + (regno - - tdep->ppc_vr0_regnum) * vrregsize + offset); + vrregset->collect_regset (vrregset, regcache, regno, ®s, + PPC_LINUX_SIZEOF_VRREGSET); 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 registers")); } -/* Assuming TID referrs to an SPE process, set the top halves of TID's +/* Assuming TID refers 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. @@ -974,7 +1120,7 @@ set_spe_registers (int tid, struct gdb_evrregset_t *evrregset) static void store_spe_register (const struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdb_evrregset_t evrregs; @@ -1001,26 +1147,23 @@ store_spe_register (const struct regcache *regcache, int tid, int regno) int i; for (i = 0; i < ppc_num_gprs; i++) - regcache_raw_collect (regcache, - tdep->ppc_ev0_upper_regnum + i, - &evrregs.evr[i]); + regcache->raw_collect (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 (regcache, regno, - &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); + regcache->raw_collect (regno, + &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]); if (regno == -1 || regno == tdep->ppc_acc_regnum) - regcache_raw_collect (regcache, - tdep->ppc_acc_regnum, - &evrregs.acc); + regcache->raw_collect (tdep->ppc_acc_regnum, + &evrregs.acc); if (regno == -1 || regno == tdep->ppc_spefscr_regnum) - regcache_raw_collect (regcache, - tdep->ppc_spefscr_regnum, - &evrregs.spefscr); + regcache->raw_collect (tdep->ppc_spefscr_regnum, + &evrregs.spefscr); /* Write back the modified register set. */ set_spe_registers (tid, &evrregs); @@ -1029,22 +1172,22 @@ store_spe_register (const struct regcache *regcache, int tid, int regno) static void store_register (const struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* This isn't really an address. But ptrace thinks of it as one. */ CORE_ADDR regaddr = ppc_register_u_addr (gdbarch, regno); int i; size_t bytes_to_transfer; - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[PPC_MAX_REGISTER_SIZE]; if (altivec_register_p (gdbarch, regno)) { - store_altivec_register (regcache, tid, regno); + store_altivec_registers (regcache, tid, regno); return; } - if (vsx_register_p (gdbarch, regno)) + else if (vsx_register_p (gdbarch, regno)) { - store_vsx_register (regcache, tid, regno); + store_vsx_registers (regcache, tid, regno); return; } else if (spe_register_p (gdbarch, regno)) @@ -1052,6 +1195,127 @@ store_register (const struct regcache *regcache, int tid, int regno) store_spe_register (regcache, tid, regno); return; } + else if (regno == PPC_DSCR_REGNUM) + { + gdb_assert (tdep->ppc_dscr_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_DSCR, + PPC_LINUX_SIZEOF_DSCRREGSET, + &ppc32_linux_dscrregset); + return; + } + else if (regno == PPC_PPR_REGNUM) + { + gdb_assert (tdep->ppc_ppr_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_PPR, + PPC_LINUX_SIZEOF_PPRREGSET, + &ppc32_linux_pprregset); + return; + } + else if (regno == PPC_TAR_REGNUM) + { + gdb_assert (tdep->ppc_tar_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_TAR, + PPC_LINUX_SIZEOF_TARREGSET, + &ppc32_linux_tarregset); + return; + } + else if (PPC_IS_EBB_REGNUM (regno)) + { + gdb_assert (tdep->have_ebb); + + store_regset (regcache, tid, regno, NT_PPC_EBB, + PPC_LINUX_SIZEOF_EBBREGSET, + &ppc32_linux_ebbregset); + return; + } + else if (PPC_IS_PMU_REGNUM (regno)) + { + gdb_assert (tdep->ppc_mmcr0_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_PMU, + PPC_LINUX_SIZEOF_PMUREGSET, + &ppc32_linux_pmuregset); + return; + } + else if (PPC_IS_TMSPR_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_spr); + + store_regset (regcache, tid, regno, NT_PPC_TM_SPR, + PPC_LINUX_SIZEOF_TM_SPRREGSET, + &ppc32_linux_tm_sprregset); + return; + } + else if (PPC_IS_CKPTGP_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_core); + + const struct regset *cgprregset = ppc_linux_cgprregset (gdbarch); + store_regset (regcache, tid, regno, NT_PPC_TM_CGPR, + (tdep->wordsize == 4? + PPC32_LINUX_SIZEOF_CGPRREGSET + : PPC64_LINUX_SIZEOF_CGPRREGSET), + cgprregset); + return; + } + else if (PPC_IS_CKPTFP_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_fpu); + + store_regset (regcache, tid, regno, NT_PPC_TM_CFPR, + PPC_LINUX_SIZEOF_CFPRREGSET, + &ppc32_linux_cfprregset); + return; + } + else if (PPC_IS_CKPTVMX_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_altivec); + + const struct regset *cvmxregset = ppc_linux_cvmxregset (gdbarch); + store_regset (regcache, tid, regno, NT_PPC_TM_CVMX, + PPC_LINUX_SIZEOF_CVMXREGSET, + cvmxregset); + return; + } + else if (PPC_IS_CKPTVSX_REGNUM (regno)) + { + gdb_assert (tdep->have_htm_vsx); + + store_regset (regcache, tid, regno, NT_PPC_TM_CVSX, + PPC_LINUX_SIZEOF_CVSXREGSET, + &ppc32_linux_cvsxregset); + return; + } + else if (regno == PPC_CPPR_REGNUM) + { + gdb_assert (tdep->ppc_cppr_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_TM_CPPR, + PPC_LINUX_SIZEOF_CPPRREGSET, + &ppc32_linux_cpprregset); + return; + } + else if (regno == PPC_CDSCR_REGNUM) + { + gdb_assert (tdep->ppc_cdscr_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_TM_CDSCR, + PPC_LINUX_SIZEOF_CDSCRREGSET, + &ppc32_linux_cdscrregset); + return; + } + else if (regno == PPC_CTAR_REGNUM) + { + gdb_assert (tdep->ppc_ctar_regnum != -1); + + store_regset (regcache, tid, regno, NT_PPC_TM_CTAR, + PPC_LINUX_SIZEOF_CTARREGSET, + &ppc32_linux_ctarregset); + return; + } if (regaddr == -1) return; @@ -1064,13 +1328,13 @@ store_register (const struct regcache *regcache, int tid, int regno) if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) { /* Little-endian values always sit at the left end of the buffer. */ - regcache_raw_collect (regcache, regno, buf); + regcache->raw_collect (regno, buf); } else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { /* Big-endian values sit at the right end of the buffer. */ size_t padding = (bytes_to_transfer - register_size (gdbarch, regno)); - regcache_raw_collect (regcache, regno, buf + padding); + regcache->raw_collect (regno, buf + padding); } for (i = 0; i < bytes_to_transfer; i += sizeof (long)) @@ -1095,95 +1359,13 @@ store_register (const struct regcache *regcache, int tid, int regno) if (errno != 0) { char message[128]; - sprintf (message, "writing register %s (#%d)", - gdbarch_register_name (gdbarch, regno), regno); + xsnprintf (message, sizeof (message), "writing register %s (#%d)", + gdbarch_register_name (gdbarch, regno), regno); perror_with_name (message); } } } -static void -fill_vsxregset (const struct regcache *regcache, gdb_vsxregset_t *vsxregsetp) -{ - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int vsxregsize = register_size (gdbarch, tdep->ppc_vsr0_upper_regnum); - - for (i = 0; i < ppc_num_vshrs; i++) - regcache_raw_collect (regcache, tdep->ppc_vsr0_upper_regnum + i, - *vsxregsetp + i * vsxregsize); -} - -static void -fill_vrregset (const struct regcache *regcache, gdb_vrregset_t *vrregsetp) -{ - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1; - int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum); - int offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum); - - 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_raw_collect (regcache, tdep->ppc_vr0_regnum + i, - *vrregsetp + i * vrregsize + offset); - else - regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i, - *vrregsetp + i * vrregsize); - } -} - -static void -store_vsx_registers (const struct regcache *regcache, int tid) -{ - int ret; - gdb_vsxregset_t regs; - - ret = ptrace (PTRACE_GETVSXREGS, tid, 0, ®s); - if (ret < 0) - { - if (errno == EIO) - { - have_ptrace_getsetvsxregs = 0; - return; - } - perror_with_name (_("Couldn't get VSX registers")); - } - - fill_vsxregset (regcache, ®s); - - if (ptrace (PTRACE_SETVSXREGS, tid, 0, ®s) < 0) - perror_with_name (_("Couldn't write VSX registers")); -} - -static void -store_altivec_registers (const struct regcache *regcache, 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 (_("Couldn't get AltiVec registers")); - } - - fill_vrregset (regcache, ®s); - - if (ptrace (PTRACE_SETVRREGS, tid, 0, ®s) < 0) - perror_with_name (_("Couldn't write AltiVec registers")); -} - /* This function actually issues the request to ptrace, telling it to store all general-purpose registers present in the specified regset. @@ -1195,8 +1377,6 @@ store_altivec_registers (const struct regcache *regcache, int tid) static int store_all_gp_regs (const struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); gdb_gregset_t gregset; if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) @@ -1233,7 +1413,7 @@ store_all_gp_regs (const struct regcache *regcache, int tid, int regno) static void store_gp_regs (const struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int i; @@ -1295,7 +1475,7 @@ store_all_fp_regs (const struct regcache *regcache, int tid, int regno) static void store_fp_regs (const struct regcache *regcache, int tid, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int i; @@ -1313,8 +1493,7 @@ store_fp_regs (const struct regcache *regcache, int tid, int regno) static void store_ppc_registers (const struct regcache *regcache, int tid) { - int i; - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); store_gp_regs (regcache, tid, -1); @@ -1342,37 +1521,52 @@ store_ppc_registers (const struct regcache *regcache, int tid) } if (have_ptrace_getvrregs) if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) - store_altivec_registers (regcache, tid); + store_altivec_registers (regcache, tid, -1); if (have_ptrace_getsetvsxregs) if (tdep->ppc_vsr0_upper_regnum != -1) - store_vsx_registers (regcache, tid); + store_vsx_registers (regcache, tid, -1); if (tdep->ppc_ev0_upper_regnum >= 0) store_spe_register (regcache, tid, -1); -} - -/* Fetch the AT_HWCAP entry from the aux vector. */ -static unsigned long -ppc_linux_get_hwcap (void) -{ - CORE_ADDR field; - - if (target_auxv_search (¤t_target, AT_HWCAP, &field)) - return (unsigned long) field; - - return 0; + if (tdep->ppc_ppr_regnum != -1) + store_regset (regcache, tid, -1, NT_PPC_PPR, + PPC_LINUX_SIZEOF_PPRREGSET, + &ppc32_linux_pprregset); + if (tdep->ppc_dscr_regnum != -1) + store_regset (regcache, tid, -1, NT_PPC_DSCR, + PPC_LINUX_SIZEOF_DSCRREGSET, + &ppc32_linux_dscrregset); + if (tdep->ppc_tar_regnum != -1) + store_regset (regcache, tid, -1, NT_PPC_TAR, + PPC_LINUX_SIZEOF_TARREGSET, + &ppc32_linux_tarregset); + + if (tdep->ppc_mmcr0_regnum != -1) + store_regset (regcache, tid, -1, NT_PPC_PMU, + PPC_LINUX_SIZEOF_PMUREGSET, + &ppc32_linux_pmuregset); + + if (tdep->have_htm_spr) + store_regset (regcache, tid, -1, NT_PPC_TM_SPR, + PPC_LINUX_SIZEOF_TM_SPRREGSET, + &ppc32_linux_tm_sprregset); + + /* Because the EBB and checkpointed HTM registers can be + unavailable, attempts to store them here would cause this + function to fail most of the time, so we ignore them. */ } /* The cached DABR value, to install in new threads. - This variable is used when we are dealing with non-BookE - processors. */ + This variable is used when the PowerPC HWDEBUG ptrace + interface is not available. */ static long saved_dabr_value; /* Global structure that will store information about the available - features on this BookE processor. */ -static struct ppc_debug_info booke_debug_info; + features provided by the PowerPC HWDEBUG ptrace interface. */ +static struct ppc_debug_info hwdebug_info; /* Global variable that holds the maximum number of slots that the - kernel will use. This is only used when the processor is BookE. */ + kernel will use. This is only used when PowerPC HWDEBUG ptrace interface + is available. */ static size_t max_slots_number = 0; struct hw_break_tuple @@ -1381,9 +1575,10 @@ struct hw_break_tuple struct ppc_hw_breakpoint *hw_break; }; -/* This is an internal VEC created to store information about *points inserted - for each thread. This is used for BookE processors. */ -typedef struct thread_points +/* This is an internal vector created to store information about *points + inserted for each thread. This is used when PowerPC HWDEBUG ptrace + interface is available. */ +struct thread_points { /* The TID to which this *point relates. */ int tid; @@ -1394,69 +1589,67 @@ typedef struct thread_points size of these vector is MAX_SLOTS_NUMBER. If the hw_break element of the tuple is NULL, then the position in the vector is free. */ struct hw_break_tuple *hw_breaks; - } *thread_points_p; -DEF_VEC_P (thread_points_p); + }; -VEC(thread_points_p) *ppc_threads = NULL; +static std::vector ppc_threads; -/* The version of the kernel interface that we will use if the processor is - BookE. */ +/* The version of the PowerPC HWDEBUG kernel interface that we will use, if + available. */ #define PPC_DEBUG_CURRENT_VERSION 1 -/* Returns non-zero if we support the ptrace interface which enables - booke debugging resources. */ +/* Returns non-zero if we support the PowerPC HWDEBUG ptrace interface. */ static int -have_ptrace_booke_interface (void) +have_ptrace_hwdebug_interface (void) { - static int have_ptrace_booke_interface = -1; + static int have_ptrace_hwdebug_interface = -1; - if (have_ptrace_booke_interface == -1) + if (have_ptrace_hwdebug_interface == -1) { int tid; - tid = TIDGET (inferior_ptid); + tid = inferior_ptid.lwp (); if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = inferior_ptid.pid (); - /* Check for kernel support for BOOKE debug registers. */ - if (ptrace (PPC_PTRACE_GETHWDBGINFO, tid, 0, &booke_debug_info) >= 0) + /* Check for kernel support for PowerPC HWDEBUG ptrace interface. */ + if (ptrace (PPC_PTRACE_GETHWDBGINFO, tid, 0, &hwdebug_info) >= 0) { - /* Check whether ptrace BOOKE interface is functional and + /* Check whether PowerPC HWDEBUG ptrace interface is functional and provides any supported feature. */ - if (booke_debug_info.features != 0) + if (hwdebug_info.features != 0) { - have_ptrace_booke_interface = 1; - max_slots_number = booke_debug_info.num_instruction_bps - + booke_debug_info.num_data_bps - + booke_debug_info.num_condition_regs; - return have_ptrace_booke_interface; + have_ptrace_hwdebug_interface = 1; + max_slots_number = hwdebug_info.num_instruction_bps + + hwdebug_info.num_data_bps + + hwdebug_info.num_condition_regs; + return have_ptrace_hwdebug_interface; } } - /* Old school interface and no BOOKE debug registers support. */ - have_ptrace_booke_interface = 0; - memset (&booke_debug_info, 0, sizeof (struct ppc_debug_info)); + /* Old school interface and no PowerPC HWDEBUG ptrace support. */ + have_ptrace_hwdebug_interface = 0; + memset (&hwdebug_info, 0, sizeof (struct ppc_debug_info)); } - return have_ptrace_booke_interface; + return have_ptrace_hwdebug_interface; } -static int -ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) +int +ppc_linux_nat_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot) { int total_hw_wp, total_hw_bp; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { - /* For PPC BookE processors, the number of available hardware - watchpoints and breakpoints is stored at the booke_debug_info - struct. */ - total_hw_bp = booke_debug_info.num_instruction_bps; - total_hw_wp = booke_debug_info.num_data_bps; + /* When PowerPC HWDEBUG ptrace interface is available, the number of + available hardware watchpoints and breakpoints is stored at the + hwdebug_info struct. */ + total_hw_bp = hwdebug_info.num_instruction_bps; + total_hw_wp = hwdebug_info.num_data_bps; } else { - /* For PPC server processors, we accept 1 hardware watchpoint and 0 - hardware breakpoints. */ + /* When we do not have PowerPC HWDEBUG ptrace interface, we should + consider having 1 hardware watchpoint and no hardware breakpoints. */ total_hw_bp = 0; total_hw_wp = 1; } @@ -1469,11 +1662,16 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) } else if (type == bp_hardware_breakpoint) { + if (total_hw_bp == 0) + { + /* No hardware breakpoint support. */ + return 0; + } if (cnt > total_hw_bp) return -1; } - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) { int tid; ptid_t ptid = inferior_ptid; @@ -1481,9 +1679,9 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) /* 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); + tid = ptid.lwp (); if (tid == 0) - tid = PIDGET (ptid); + tid = ptid.pid (); if (ptrace (PTRACE_SET_DEBUGREG, tid, 0, 0) == -1) return 0; @@ -1492,36 +1690,47 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) return 1; } -static int -ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) +int +ppc_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) { /* Handle sub-8-byte quantities. */ if (len <= 0) return 0; - /* The new BookE ptrace interface tells if there are alignment restrictions - for watchpoints in the processors. In that case, we use that information - to determine the hardcoded watchable region for watchpoints. */ - if (have_ptrace_booke_interface ()) - { - /* DAC-based processors (i.e., embedded processors), like the PowerPC 440 - have ranged watchpoints and can watch any access within an arbitrary - memory region. This is useful to watch arrays and structs, for - instance. It takes two hardware watchpoints though. */ + /* The PowerPC HWDEBUG ptrace interface tells if there are alignment + restrictions for watchpoints in the processors. In that case, we use that + information to determine the hardcoded watchable region for + watchpoints. */ + if (have_ptrace_hwdebug_interface ()) + { + int region_size; + /* Embedded DAC-based processors, like the PowerPC 440 have ranged + watchpoints and can watch any access within an arbitrary memory + region. This is useful to watch arrays and structs, for instance. It + takes two hardware watchpoints though. */ if (len > 1 - && booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE) + && hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE + && linux_get_hwcap (current_top_target ()) & PPC_FEATURE_BOOKE) return 2; - else if (booke_debug_info.data_bp_alignment - && (addr + len > (addr & ~(booke_debug_info.data_bp_alignment - 1)) - + booke_debug_info.data_bp_alignment)) + /* Check if the processor provides DAWR interface. */ + if (hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_DAWR) + /* DAWR interface allows to watch up to 512 byte wide ranges which + can't cross a 512 byte boundary. */ + region_size = 512; + else + region_size = hwdebug_info.data_bp_alignment; + /* Server processors provide one hardware watchpoint and addr+len should + fall in the watchable region provided by the ptrace interface. */ + if (region_size + && (addr + len > (addr & ~(region_size - 1)) + region_size)) return 0; } /* addr+len must fall in the 8 byte watchable region for DABR-based - processors (i.e., server processors). Without the new BookE ptrace - interface, DAC-based processors (i.e., embedded processors) will use - addresses aligned to 4-bytes due to the way the read/write flags are + processors (i.e., server processors). Without the new PowerPC HWDEBUG + ptrace interface, DAC-based processors (i.e., embedded processors) will + use addresses aligned to 4-bytes due to the way the read/write flags are passed in the old ptrace interface. */ - else if (((ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) + else if (((linux_get_hwcap (current_top_target ()) & PPC_FEATURE_BOOKE) && (addr + len) > (addr & ~3) + 4) || (addr + len) > (addr & ~7) + 8) return 0; @@ -1531,7 +1740,7 @@ ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) /* This function compares two ppc_hw_breakpoint structs field-by-field. */ static int -booke_cmp_hw_point (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) +hwdebug_point_cmp (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) { return (a->trigger_type == b->trigger_type && a->addr_mode == b->addr_mode @@ -1546,26 +1755,24 @@ booke_cmp_hw_point (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) it returns NULL. If ALLOC_NEW is non-zero, a new thread_points for the provided TID will be created and returned. */ static struct thread_points * -booke_find_thread_points_by_tid (int tid, int alloc_new) +hwdebug_find_thread_points_by_tid (int tid, int alloc_new) { - int i; - struct thread_points *t; - - for (i = 0; VEC_iterate (thread_points_p, ppc_threads, i, t); i++) - if (t->tid == tid) - return t; + for (thread_points *t : ppc_threads) + { + if (t->tid == tid) + return t; + } - t = NULL; + struct thread_points *t = NULL; /* Do we need to allocate a new point_item if the wanted one does not exist? */ if (alloc_new) { - t = xmalloc (sizeof (struct thread_points)); - t->hw_breaks - = xzalloc (max_slots_number * sizeof (struct hw_break_tuple)); + t = XNEW (struct thread_points); + t->hw_breaks = XCNEWVEC (struct hw_break_tuple, max_slots_number); t->tid = tid; - VEC_safe_push (thread_points_p, ppc_threads, t); + ppc_threads.push_back (t); } return t; @@ -1575,58 +1782,54 @@ booke_find_thread_points_by_tid (int tid, int alloc_new) *point (i.e., calling `ptrace' in order to issue the request to the kernel) and registering it internally in GDB. */ static void -booke_insert_point (struct ppc_hw_breakpoint *b, int tid) +hwdebug_insert_point (struct ppc_hw_breakpoint *b, int tid) { int i; long slot; - struct ppc_hw_breakpoint *p = xmalloc (sizeof (struct ppc_hw_breakpoint)); + gdb::unique_xmalloc_ptr p (XDUP (ppc_hw_breakpoint, b)); struct hw_break_tuple *hw_breaks; - struct cleanup *c = make_cleanup (xfree, p); struct thread_points *t; - struct hw_break_tuple *tuple; - - memcpy (p, b, sizeof (struct ppc_hw_breakpoint)); errno = 0; - slot = ptrace (PPC_PTRACE_SETHWDEBUG, tid, 0, p); + slot = ptrace (PPC_PTRACE_SETHWDEBUG, tid, 0, p.get ()); if (slot < 0) perror_with_name (_("Unexpected error setting breakpoint or watchpoint")); /* Everything went fine, so we have to register this *point. */ - t = booke_find_thread_points_by_tid (tid, 1); + t = hwdebug_find_thread_points_by_tid (tid, 1); gdb_assert (t != NULL); hw_breaks = t->hw_breaks; /* Find a free element in the hw_breaks vector. */ for (i = 0; i < max_slots_number; i++) - if (hw_breaks[i].hw_break == NULL) - { - hw_breaks[i].slot = slot; - hw_breaks[i].hw_break = p; - break; - } + { + if (hw_breaks[i].hw_break == NULL) + { + hw_breaks[i].slot = slot; + hw_breaks[i].hw_break = p.release (); + break; + } + } gdb_assert (i != max_slots_number); - - discard_cleanups (c); } /* This function is a generic wrapper that is responsible for removing a *point (i.e., calling `ptrace' in order to issue the request to the kernel), and unregistering it internally at GDB. */ static void -booke_remove_point (struct ppc_hw_breakpoint *b, int tid) +hwdebug_remove_point (struct ppc_hw_breakpoint *b, int tid) { int i; struct hw_break_tuple *hw_breaks; struct thread_points *t; - t = booke_find_thread_points_by_tid (tid, 0); + t = hwdebug_find_thread_points_by_tid (tid, 0); gdb_assert (t != NULL); hw_breaks = t->hw_breaks; for (i = 0; i < max_slots_number; i++) - if (hw_breaks[i].hw_break && booke_cmp_hw_point (hw_breaks[i].hw_break, b)) + if (hw_breaks[i].hw_break && hwdebug_point_cmp (hw_breaks[i].hw_break, b)) break; gdb_assert (i != max_slots_number); @@ -1646,31 +1849,31 @@ booke_remove_point (struct ppc_hw_breakpoint *b, int tid) /* Return the number of registers needed for a ranged breakpoint. */ -static int -ppc_linux_ranged_break_num_registers (struct target_ops *target) +int +ppc_linux_nat_target::ranged_break_num_registers () { - return ((have_ptrace_booke_interface () - && booke_debug_info.features & PPC_DEBUG_FEATURE_INSN_BP_RANGE)? + return ((have_ptrace_hwdebug_interface () + && hwdebug_info.features & PPC_DEBUG_FEATURE_INSN_BP_RANGE)? 2 : -1); } /* Insert the hardware breakpoint described by BP_TGT. Returns 0 for success, 1 if hardware breakpoints are not supported or -1 for failure. */ -static int -ppc_linux_insert_hw_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) +int +ppc_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { struct lwp_info *lp; struct ppc_hw_breakpoint p; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return -1; p.version = PPC_DEBUG_CURRENT_VERSION; p.trigger_type = PPC_BREAKPOINT_TRIGGER_EXECUTE; p.condition_mode = PPC_BREAKPOINT_CONDITION_NONE; - p.addr = (uint64_t) bp_tgt->placed_address; + p.addr = (uint64_t) (bp_tgt->placed_address = bp_tgt->reqstd_address); p.condition_value = 0; if (bp_tgt->length) @@ -1688,19 +1891,19 @@ ppc_linux_insert_hw_breakpoint (struct gdbarch *gdbarch, } ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, lp->ptid.lwp ()); return 0; } -static int -ppc_linux_remove_hw_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) +int +ppc_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { struct lwp_info *lp; struct ppc_hw_breakpoint p; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return -1; p.version = PPC_DEBUG_CURRENT_VERSION; @@ -1724,19 +1927,19 @@ ppc_linux_remove_hw_breakpoint (struct gdbarch *gdbarch, } ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, lp->ptid.lwp ()); return 0; } static int -get_trigger_type (int rw) +get_trigger_type (enum target_hw_bp_type type) { int t; - if (rw == hw_read) + if (type == hw_read) t = PPC_BREAKPOINT_TRIGGER_READ; - else if (rw == hw_write) + else if (type == hw_write) t = PPC_BREAKPOINT_TRIGGER_WRITE; else t = PPC_BREAKPOINT_TRIGGER_READ | PPC_BREAKPOINT_TRIGGER_WRITE; @@ -1749,14 +1952,14 @@ get_trigger_type (int rw) or hw_access for an access watchpoint. Returns 0 on success and throws an error on failure. */ -static int -ppc_linux_insert_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, - CORE_ADDR mask, int rw) +int +ppc_linux_nat_target::insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, + target_hw_bp_type rw) { struct lwp_info *lp; struct ppc_hw_breakpoint p; - gdb_assert (have_ptrace_booke_interface ()); + gdb_assert (have_ptrace_hwdebug_interface ()); p.version = PPC_DEBUG_CURRENT_VERSION; p.trigger_type = get_trigger_type (rw); @@ -1767,7 +1970,7 @@ ppc_linux_insert_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, p.condition_value = 0; ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, lp->ptid.lwp ()); return 0; } @@ -1777,14 +1980,14 @@ ppc_linux_insert_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, or hw_access for an access watchpoint. Returns 0 on success and throws an error on failure. */ -static int -ppc_linux_remove_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, - CORE_ADDR mask, int rw) +int +ppc_linux_nat_target::remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, + target_hw_bp_type rw) { struct lwp_info *lp; struct ppc_hw_breakpoint p; - gdb_assert (have_ptrace_booke_interface ()); + gdb_assert (have_ptrace_hwdebug_interface ()); p.version = PPC_DEBUG_CURRENT_VERSION; p.trigger_type = get_trigger_type (rw); @@ -1795,7 +1998,7 @@ ppc_linux_remove_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, p.condition_value = 0; ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, lp->ptid.lwp ()); return 0; } @@ -1805,14 +2008,13 @@ static int can_use_watchpoint_cond_accel (void) { struct thread_points *p; - int tid = TIDGET (inferior_ptid); - int cnt = booke_debug_info.num_condition_regs, i; - CORE_ADDR tmp_value; + int tid = inferior_ptid.lwp (); + int cnt = hwdebug_info.num_condition_regs, i; - if (!have_ptrace_booke_interface () || cnt == 0) + if (!have_ptrace_hwdebug_interface () || cnt == 0) return 0; - p = booke_find_thread_points_by_tid (tid, 0); + p = hwdebug_find_thread_points_by_tid (tid, 0); if (p) { @@ -1851,10 +2053,10 @@ calculate_dvc (CORE_ADDR addr, int len, CORE_ADDR data_value, We need to calculate where our watch region is relative to that window and enable comparison of the bytes which fall within it. */ - align_offset = addr % booke_debug_info.sizeof_condition; + align_offset = addr % hwdebug_info.sizeof_condition; addr_end_data = addr + len; addr_end_dvc = (addr - align_offset - + booke_debug_info.sizeof_condition); + + hwdebug_info.sizeof_condition); num_bytes_off_dvc = (addr_end_data > addr_end_dvc)? addr_end_data - addr_end_dvc : 0; num_byte_enable = len - num_bytes_off_dvc; @@ -1881,10 +2083,9 @@ calculate_dvc (CORE_ADDR addr, int len, CORE_ADDR data_value, other kinds of values which are not acceptable in a condition expression (e.g., lval_computed or lval_internalvar). */ static int -num_memory_accesses (struct value *v) +num_memory_accesses (const std::vector &chain) { int found_memory_cnt = 0; - struct value *head = v; /* The idea here is that evaluating an expression generates a series of values, one holding the value of every subexpression. (The @@ -1901,8 +2102,10 @@ num_memory_accesses (struct value *v) notice that an expression contains an inferior function call. FIXME. */ - for (; v; v = value_next (v)) + for (const value_ref_ptr &iter : chain) { + struct value *v = iter.get (); + /* Constants and values from the history are fine. */ if (VALUE_LVAL (v) == not_lval || deprecated_value_modifiable (v) == 0) continue; @@ -1933,31 +2136,23 @@ check_condition (CORE_ADDR watch_addr, struct expression *cond, CORE_ADDR *data_value, int *len) { int pc = 1, num_accesses_left, num_accesses_right; - struct value *left_val, *right_val, *left_chain, *right_chain; + struct value *left_val, *right_val; + std::vector left_chain, right_chain; if (cond->elts[0].opcode != BINOP_EQUAL) return 0; - fetch_subexp_value (cond, &pc, &left_val, NULL, &left_chain); + fetch_subexp_value (cond, &pc, &left_val, NULL, &left_chain, 0); num_accesses_left = num_memory_accesses (left_chain); if (left_val == NULL || num_accesses_left < 0) - { - free_value_chain (left_chain); - - return 0; - } + return 0; - fetch_subexp_value (cond, &pc, &right_val, NULL, &right_chain); + fetch_subexp_value (cond, &pc, &right_val, NULL, &right_chain, 0); num_accesses_right = num_memory_accesses (right_chain); if (right_val == NULL || num_accesses_right < 0) - { - free_value_chain (left_chain); - free_value_chain (right_chain); - - return 0; - } + return 0; if (num_accesses_left == 1 && num_accesses_right == 0 && VALUE_LVAL (left_val) == lval_memory @@ -1980,15 +2175,7 @@ check_condition (CORE_ADDR watch_addr, struct expression *cond, *len = TYPE_LENGTH (check_typedef (value_type (right_val))); } else - { - free_value_chain (left_chain); - free_value_chain (right_chain); - - return 0; - } - - free_value_chain (left_chain); - free_value_chain (right_chain); + return 0; return 1; } @@ -1996,14 +2183,15 @@ check_condition (CORE_ADDR watch_addr, struct expression *cond, /* Return non-zero if the target is capable of using hardware to evaluate the condition expression, thus only triggering the watchpoint when it is true. */ -static int -ppc_linux_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw, - struct expression *cond) +bool +ppc_linux_nat_target::can_accel_watchpoint_condition (CORE_ADDR addr, int len, + int rw, + struct expression *cond) { CORE_ADDR data_value; - return (have_ptrace_booke_interface () - && booke_debug_info.num_condition_regs > 0 + return (have_ptrace_hwdebug_interface () + && hwdebug_info.num_condition_regs > 0 && check_condition (addr, cond, &data_value, &len)); } @@ -2014,17 +2202,17 @@ ppc_linux_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw, static void create_watchpoint_request (struct ppc_hw_breakpoint *p, CORE_ADDR addr, - int len, int rw, struct expression *cond, - int insert) + int len, enum target_hw_bp_type type, + struct expression *cond, int insert) { if (len == 1 - || !(booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE)) + || !(hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE)) { int use_condition; CORE_ADDR data_value; use_condition = (insert? can_use_watchpoint_cond_accel () - : booke_debug_info.num_condition_regs > 0); + : hwdebug_info.num_condition_regs > 0); if (cond && use_condition && check_condition (addr, cond, &data_value, &len)) calculate_dvc (addr, len, data_value, &p->condition_mode, @@ -2054,25 +2242,26 @@ create_watchpoint_request (struct ppc_hw_breakpoint *p, CORE_ADDR addr, } p->version = PPC_DEBUG_CURRENT_VERSION; - p->trigger_type = get_trigger_type (rw); + p->trigger_type = get_trigger_type (type); p->addr = (uint64_t) addr; } -static int -ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, - struct expression *cond) +int +ppc_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) { struct lwp_info *lp; int ret = -1; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { struct ppc_hw_breakpoint p; - create_watchpoint_request (&p, addr, len, rw, cond, 1); + create_watchpoint_request (&p, addr, len, type, cond, 1); ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, lp->ptid.lwp ()); ret = 0; } @@ -2081,7 +2270,7 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, long dabr_value; long read_mode, write_mode; - if (ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) + if (linux_get_hwcap (current_top_target ()) & PPC_FEATURE_BOOKE) { /* PowerPC 440 requires only the read/write flags to be passed to the kernel. */ @@ -2097,7 +2286,7 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, } dabr_value = addr & ~(read_mode | write_mode); - switch (rw) + switch (type) { case hw_read: /* Set read and translate bits. */ @@ -2116,7 +2305,7 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, saved_dabr_value = dabr_value; ALL_LWPS (lp) - if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (lp->ptid), 0, + if (ptrace (PTRACE_SET_DEBUGREG, lp->ptid.lwp (), 0, saved_dabr_value) < 0) return -1; @@ -2126,21 +2315,22 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, return ret; } -static int -ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, - struct expression *cond) +int +ppc_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) { struct lwp_info *lp; int ret = -1; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { struct ppc_hw_breakpoint p; - create_watchpoint_request (&p, addr, len, rw, cond, 0); + create_watchpoint_request (&p, addr, len, type, cond, 0); ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, lp->ptid.lwp ()); ret = 0; } @@ -2148,7 +2338,7 @@ ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, { saved_dabr_value = 0; ALL_LWPS (lp) - if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (lp->ptid), 0, + if (ptrace (PTRACE_SET_DEBUGREG, lp->ptid.lwp (), 0, saved_dabr_value) < 0) return -1; @@ -2158,28 +2348,39 @@ ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, return ret; } -static void -ppc_linux_new_thread (struct lwp_info *lp) +void +ppc_linux_nat_target::low_new_thread (struct lwp_info *lp) { - int tid = TIDGET (lp->ptid); + int tid = lp->ptid.lwp (); - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { int i; struct thread_points *p; struct hw_break_tuple *hw_breaks; - if (VEC_empty (thread_points_p, ppc_threads)) + if (ppc_threads.empty ()) return; /* Get a list of breakpoints from any thread. */ - p = VEC_last (thread_points_p, ppc_threads); + p = ppc_threads.back (); hw_breaks = p->hw_breaks; /* Copy that thread's breakpoints and watchpoints to the new thread. */ for (i = 0; i < max_slots_number; i++) if (hw_breaks[i].hw_break) - booke_insert_point (hw_breaks[i].hw_break, tid); + { + /* Older kernels did not make new threads inherit their parent + thread's debug state, so we always clear the slot and replicate + the debug state ourselves, ensuring compatibility with all + kernels. */ + + /* The ppc debug resource accounting is done through "slots". + Ask the kernel the deallocate this specific *point's slot. */ + ptrace (PPC_PTRACE_DELHWDEBUG, tid, 0, hw_breaks[i].slot); + + hwdebug_insert_point (hw_breaks[i].hw_break, tid); + } } else ptrace (PTRACE_SET_DEBUGREG, tid, 0, saved_dabr_value); @@ -2189,24 +2390,26 @@ static void ppc_linux_thread_exit (struct thread_info *tp, int silent) { int i; - int tid = TIDGET (tp->ptid); + int tid = tp->ptid.lwp (); struct hw_break_tuple *hw_breaks; - struct thread_points *t = NULL, *p; + struct thread_points *t = NULL; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return; - for (i = 0; VEC_iterate (thread_points_p, ppc_threads, i, p); i++) - if (p->tid == tid) - { - t = p; - break; - } + for (i = 0; i < ppc_threads.size (); i++) + { + if (ppc_threads[i]->tid == tid) + { + t = ppc_threads[i]; + break; + } + } if (t == NULL) return; - VEC_unordered_remove (thread_points_p, ppc_threads, i); + unordered_remove (ppc_threads, i); hw_breaks = t->hw_breaks; @@ -2218,19 +2421,19 @@ ppc_linux_thread_exit (struct thread_info *tp, int silent) xfree (t); } -static int -ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) +bool +ppc_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p) { siginfo_t siginfo; if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) - return 0; + return false; if (siginfo.si_signo != SIGTRAP || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) - return 0; + return false; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { int i; struct thread_points *t; @@ -2238,7 +2441,7 @@ ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) /* The index (or slot) of the *point is passed in the si_errno field. */ int slot = siginfo.si_errno; - t = booke_find_thread_points_by_tid (TIDGET (inferior_ptid), 0); + t = hwdebug_find_thread_points_by_tid (inferior_ptid.lwp (), 0); /* Find out if this *point is a hardware breakpoint. If so, we should return 0. */ @@ -2249,32 +2452,32 @@ ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) if (hw_breaks[i].hw_break && hw_breaks[i].slot == slot && hw_breaks[i].hw_break->trigger_type == PPC_BREAKPOINT_TRIGGER_EXECUTE) - return 0; + return false; } } *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr; - return 1; + return true; } -static int -ppc_linux_stopped_by_watchpoint (void) +bool +ppc_linux_nat_target::stopped_by_watchpoint () { CORE_ADDR addr; - return ppc_linux_stopped_data_address (¤t_target, &addr); + return stopped_data_address (&addr); } -static int -ppc_linux_watchpoint_addr_within_range (struct target_ops *target, - CORE_ADDR addr, - CORE_ADDR start, int length) +bool +ppc_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr, + CORE_ADDR start, + int length) { int mask; - if (have_ptrace_booke_interface () - && ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) + if (have_ptrace_hwdebug_interface () + && linux_get_hwcap (current_top_target ()) & PPC_FEATURE_BOOKE) return start <= addr && start + length >= addr; - else if (ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) + else if (linux_get_hwcap (current_top_target ()) & PPC_FEATURE_BOOKE) mask = 3; else mask = 7; @@ -2287,12 +2490,11 @@ ppc_linux_watchpoint_addr_within_range (struct target_ops *target, /* Return the number of registers needed for a masked hardware watchpoint. */ -static int -ppc_linux_masked_watch_num_registers (struct target_ops *target, - CORE_ADDR addr, CORE_ADDR mask) +int +ppc_linux_nat_target::masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask) { - if (!have_ptrace_booke_interface () - || (booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_MASK) == 0) + if (!have_ptrace_hwdebug_interface () + || (hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_MASK) == 0) return -1; else if ((mask & 0xC0000000) != 0xC0000000) { @@ -2305,16 +2507,10 @@ ppc_linux_masked_watch_num_registers (struct target_ops *target, return 2; } -static void -ppc_linux_store_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +ppc_linux_nat_target::store_registers (struct regcache *regcache, int regno) { - /* 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); + pid_t tid = get_ptrace_pid (regcache->ptid ()); if (regno >= 0) store_register (regcache, tid, regno); @@ -2366,34 +2562,17 @@ fill_fpregset (const struct regcache *regcache, fpregsetp, sizeof (*fpregsetp)); } -static int -ppc_linux_target_wordsize (void) +int +ppc_linux_nat_target::auxv_parse (gdb_byte **readptr, + gdb_byte *endptr, CORE_ADDR *typep, + CORE_ADDR *valp) { - int wordsize = 4; - - /* Check for 64-bit inferior process. This is the case when the host is - 64-bit, and in addition the top bit of the MSR register is set. */ -#ifdef __powerpc64__ - long msr; - - int tid = TIDGET (inferior_ptid); + int tid = inferior_ptid.lwp (); if (tid == 0) - tid = PIDGET (inferior_ptid); - - errno = 0; - msr = (long) ptrace (PTRACE_PEEKUSER, tid, PT_MSR * 8, 0); - if (errno == 0 && msr < 0) - wordsize = 8; -#endif + tid = inferior_ptid.pid (); - return wordsize; -} + int sizeof_auxv_field = ppc_linux_target_wordsize (tid); -static int -ppc_linux_auxv_parse (struct target_ops *ops, gdb_byte **readptr, - gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) -{ - int sizeof_auxv_field = ppc_linux_target_wordsize (); enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); gdb_byte *ptr = *readptr; @@ -2412,17 +2591,12 @@ ppc_linux_auxv_parse (struct target_ops *ops, gdb_byte **readptr, return 1; } -static const struct target_desc * -ppc_linux_read_description (struct target_ops *ops) +const struct target_desc * +ppc_linux_nat_target::read_description () { - int altivec = 0; - int vsx = 0; - int isa205 = 0; - int cell = 0; - - int tid = TIDGET (inferior_ptid); + int tid = inferior_ptid.lwp (); if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = inferior_ptid.pid (); if (have_ptrace_getsetevrregs) { @@ -2437,12 +2611,20 @@ ppc_linux_read_description (struct target_ops *ops) perror_with_name (_("Unable to fetch SPE registers")); } - if (have_ptrace_getsetvsxregs) + struct ppc_linux_features features = ppc_linux_no_features; + + features.wordsize = ppc_linux_target_wordsize (tid); + + CORE_ADDR hwcap = linux_get_hwcap (current_top_target ()); + CORE_ADDR hwcap2 = linux_get_hwcap2 (current_top_target ()); + + if (have_ptrace_getsetvsxregs + && (hwcap & PPC_FEATURE_HAS_VSX)) { gdb_vsxregset_t vsxregset; if (ptrace (PTRACE_GETVSXREGS, tid, 0, &vsxregset) >= 0) - vsx = 1; + features.vsx = true; /* EIO means that the PTRACE_GETVSXREGS request isn't supported. Anything else needs to be reported. */ @@ -2450,12 +2632,13 @@ ppc_linux_read_description (struct target_ops *ops) perror_with_name (_("Unable to fetch VSX registers")); } - if (have_ptrace_getvrregs) + if (have_ptrace_getvrregs + && (hwcap & PPC_FEATURE_HAS_ALTIVEC)) { gdb_vrregset_t vrregset; if (ptrace (PTRACE_GETVRREGS, tid, 0, &vrregset) >= 0) - altivec = 1; + features.altivec = true; /* EIO means that the PTRACE_GETVRREGS request isn't supported. Anything else needs to be reported. */ @@ -2463,78 +2646,38 @@ ppc_linux_read_description (struct target_ops *ops) perror_with_name (_("Unable to fetch AltiVec registers")); } - /* Power ISA 2.05 (implemented by Power 6 and newer processors) increases - the FPSCR from 32 bits to 64 bits. Even though Power 7 supports this - ISA version, it doesn't have PPC_FEATURE_ARCH_2_05 set, only - PPC_FEATURE_ARCH_2_06. Since for now the only bits used in the higher - half of the register are for Decimal Floating Point, we check if that - feature is available to decide the size of the FPSCR. */ - if (ppc_linux_get_hwcap () & PPC_FEATURE_HAS_DFP) - isa205 = 1; - - if (ppc_linux_get_hwcap () & PPC_FEATURE_CELL) - cell = 1; + features.isa205 = ppc_linux_has_isa205 (hwcap); - if (ppc_linux_target_wordsize () == 8) + if ((hwcap2 & PPC_FEATURE2_DSCR) + && check_regset (tid, NT_PPC_PPR, PPC_LINUX_SIZEOF_PPRREGSET) + && check_regset (tid, NT_PPC_DSCR, PPC_LINUX_SIZEOF_DSCRREGSET)) { - if (cell) - return tdesc_powerpc_cell64l; - else if (vsx) - return isa205? tdesc_powerpc_isa205_vsx64l : tdesc_powerpc_vsx64l; - else if (altivec) - return isa205 - ? tdesc_powerpc_isa205_altivec64l : tdesc_powerpc_altivec64l; - - return isa205? tdesc_powerpc_isa205_64l : tdesc_powerpc_64l; + features.ppr_dscr = true; + if ((hwcap2 & PPC_FEATURE2_ARCH_2_07) + && (hwcap2 & PPC_FEATURE2_TAR) + && (hwcap2 & PPC_FEATURE2_EBB) + && check_regset (tid, NT_PPC_TAR, PPC_LINUX_SIZEOF_TARREGSET) + && check_regset (tid, NT_PPC_EBB, PPC_LINUX_SIZEOF_EBBREGSET) + && check_regset (tid, NT_PPC_PMU, PPC_LINUX_SIZEOF_PMUREGSET)) + { + features.isa207 = true; + if ((hwcap2 & PPC_FEATURE2_HTM) + && check_regset (tid, NT_PPC_TM_SPR, + PPC_LINUX_SIZEOF_TM_SPRREGSET)) + features.htm = true; + } } - if (cell) - return tdesc_powerpc_cell32l; - else if (vsx) - return isa205? tdesc_powerpc_isa205_vsx32l : tdesc_powerpc_vsx32l; - else if (altivec) - return isa205? tdesc_powerpc_isa205_altivec32l : tdesc_powerpc_altivec32l; - - return isa205? tdesc_powerpc_isa205_32l : tdesc_powerpc_32l; + return ppc_linux_match_description (features); } -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 (); + linux_target = &the_ppc_linux_nat_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 breakpoint/watchpoint methods. */ - t->to_can_use_hw_breakpoint = ppc_linux_can_use_hw_breakpoint; - t->to_insert_hw_breakpoint = ppc_linux_insert_hw_breakpoint; - t->to_remove_hw_breakpoint = ppc_linux_remove_hw_breakpoint; - 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_insert_mask_watchpoint = ppc_linux_insert_mask_watchpoint; - t->to_remove_mask_watchpoint = ppc_linux_remove_mask_watchpoint; - t->to_stopped_by_watchpoint = ppc_linux_stopped_by_watchpoint; - t->to_stopped_data_address = ppc_linux_stopped_data_address; - t->to_watchpoint_addr_within_range = ppc_linux_watchpoint_addr_within_range; - t->to_can_accel_watchpoint_condition - = ppc_linux_can_accel_watchpoint_condition; - t->to_masked_watch_num_registers = ppc_linux_masked_watch_num_registers; - t->to_ranged_break_num_registers = ppc_linux_ranged_break_num_registers; - - t->to_read_description = ppc_linux_read_description; - t->to_auxv_parse = ppc_linux_auxv_parse; - - observer_attach_thread_exit (ppc_linux_thread_exit); + gdb::observers::thread_exit.attach (ppc_linux_thread_exit); /* Register the target. */ - linux_nat_add_target (t); - linux_nat_set_new_thread (t, ppc_linux_new_thread); + add_inf_child_target (linux_target); }