34#include "gdbsupport/gdb_wait.h"
36#include <sys/procfs.h>
41#include <unordered_map>
50#include "elf/common.h"
61#ifndef PTRACE_GET_DEBUGREG
62#define PTRACE_GET_DEBUGREG 25
64#ifndef PTRACE_SET_DEBUGREG
65#define PTRACE_SET_DEBUGREG 26
67#ifndef PTRACE_GETSIGINFO
68#define PTRACE_GETSIGINFO 0x4202
75#ifndef PPC_PTRACE_GETHWDBGINFO
80#define PPC_PTRACE_GETHWDBGINFO 0x89
81#define PPC_PTRACE_SETHWDEBUG 0x88
82#define PPC_PTRACE_DELHWDEBUG 0x87
96#define PPC_DEBUG_FEATURE_INSN_BP_RANGE 0x1
97#define PPC_DEBUG_FEATURE_INSN_BP_MASK 0x2
98#define PPC_DEBUG_FEATURE_DATA_BP_RANGE 0x4
99#define PPC_DEBUG_FEATURE_DATA_BP_MASK 0x8
113#define PPC_BREAKPOINT_TRIGGER_EXECUTE 0x1
114#define PPC_BREAKPOINT_TRIGGER_READ 0x2
115#define PPC_BREAKPOINT_TRIGGER_WRITE 0x4
116#define PPC_BREAKPOINT_TRIGGER_RW 0x6
119#define PPC_BREAKPOINT_MODE_EXACT 0x0
120#define PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE 0x1
121#define PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE 0x2
122#define PPC_BREAKPOINT_MODE_MASK 0x3
125#define PPC_BREAKPOINT_CONDITION_NONE 0x0
126#define PPC_BREAKPOINT_CONDITION_AND 0x1
127#define PPC_BREAKPOINT_CONDITION_EXACT 0x1
128#define PPC_BREAKPOINT_CONDITION_OR 0x2
129#define PPC_BREAKPOINT_CONDITION_AND_OR 0x3
130#define PPC_BREAKPOINT_CONDITION_BE_ALL 0x00ff0000
131#define PPC_BREAKPOINT_CONDITION_BE_SHIFT 16
132#define PPC_BREAKPOINT_CONDITION_BE(n) \
133 (1<<((n)+PPC_BREAKPOINT_CONDITION_BE_SHIFT))
138#ifndef PPC_DEBUG_FEATURE_DATA_BP_DAWR
139#define PPC_DEBUG_FEATURE_DATA_BP_DAWR 0x10
143#ifndef PPC_DEBUG_FEATURE_DATA_BP_ARCH_31
144#define PPC_DEBUG_FEATURE_DATA_BP_ARCH_31 0x20
149#define PPC_DEBUG_CURRENT_VERSION 1
153#ifndef PTRACE_GETREGS
154#define PTRACE_GETREGS 12
156#ifndef PTRACE_SETREGS
157#define PTRACE_SETREGS 13
159#ifndef PTRACE_GETFPREGS
160#define PTRACE_GETFPREGS 14
162#ifndef PTRACE_SETFPREGS
163#define PTRACE_SETFPREGS 15
381 gdb_assert (ptid.lwp_p ());
383 bool no_features =
false;
428 if (no_features || errno == EIO)
440 warning (_(
"Error when detecting the debug register interface. "
441 "Debug registers will be unavailable."));
532 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
555 const ptid_t &child_ptid);
574 CORE_ADDR data_value,
575 uint32_t *condition_mode,
576 uint64_t *condition_value);
580 CORE_ADDR *data_value,
int *len);
589 enum target_hw_bp_type
type,
613 return std::hash<long>{} (ptid.lwp ());
622 std::unordered_map <ptid_t,
623 std::list<std::pair<long, ppc_hw_breakpoint>>,
651 int wordsize =
sizeof (long);
664 u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->
ppc_fp0_regnum) * 8);
668 u_addr = PT_NIP * wordsize;
670 u_addr = PT_LNK * wordsize;
672 u_addr = PT_CCR * wordsize;
674 u_addr = PT_XER * wordsize;
676 u_addr = PT_CTR * wordsize;
679 u_addr = PT_MQ * wordsize;
682 u_addr = PT_MSR * wordsize;
697 if (wordsize == 8 && PT_FPSCR == (48 + 32 + 1))
698 u_addr = (48 + 32) * wordsize;
703 && PT_FPSCR == (48 + 2*32 + 1))
704 u_addr = (48 + 2*32) * wordsize;
706 u_addr = PT_FPSCR * wordsize;
729 perror_with_name (_(
"Unable to fetch VSX registers"));
756 perror_with_name (_(
"Unable to fetch AltiVec registers"));
786 perror_with_name (_(
"Unable to fetch SPE registers"));
790 memset (evrregset, 0,
sizeof (*evrregset));
804 gdb_assert (
sizeof (evrregs.
evr[0])
806 gdb_assert (
sizeof (evrregs.
acc)
808 gdb_assert (
sizeof (evrregs.
spefscr)
842 int regset_id,
int regsetsize,
const struct regset *
regset)
844 void *buf = alloca (regsetsize);
848 iov.iov_len = regsetsize;
852 if (errno == ENODATA)
855 perror_with_name (_(
"Couldn't get register set"));
868 int regset_id,
int regsetsize,
const struct regset *
regset)
870 void *buf = alloca (regsetsize);
874 iov.iov_len = regsetsize;
879 perror_with_name (_(
"Couldn't get register set"));
884 perror_with_name (_(
"Couldn't set register set"));
893 void *buf = alloca (regsetsize);
897 iov.iov_len = regsetsize;
913 int bytes_transferred;
1076 for (bytes_transferred = 0;
1078 bytes_transferred +=
sizeof (long))
1084 regaddr +=
sizeof (long);
1088 xsnprintf (message,
sizeof (message),
"reading register %s (#%d)",
1090 perror_with_name (message);
1092 memcpy (&buf[bytes_transferred], &l,
sizeof (l));
1112 internal_error (_(
"fetch_register: unexpected byte order: %d"),
1136 perror_with_name (_(
"Couldn't get general-purpose registers"));
1188 perror_with_name (_(
"Couldn't get floating-point registers"));
1348 perror_with_name (_(
"Unable to fetch VSX registers"));
1356 perror_with_name (_(
"Unable to store VSX registers"));
1376 perror_with_name (_(
"Unable to fetch AltiVec registers"));
1384 perror_with_name (_(
"Unable to store AltiVec registers"));
1411 perror_with_name (_(
"Unable to set SPE registers"));
1426 gdb_assert (
sizeof (evrregs.
evr[0])
1428 gdb_assert (
sizeof (evrregs.
acc)
1430 gdb_assert (
sizeof (evrregs.
spefscr)
1437 memset (&evrregs, 42,
sizeof (evrregs));
1479 size_t bytes_to_transfer;
1625 memset (buf, 0,
sizeof buf);
1639 for (i = 0; i < bytes_to_transfer; i +=
sizeof (long))
1643 memcpy (&l, &buf[i],
sizeof (l));
1646 regaddr +=
sizeof (long);
1661 xsnprintf (message,
sizeof (message),
"writing register %s (#%d)",
1663 perror_with_name (message);
1688 perror_with_name (_(
"Couldn't get general-purpose registers"));
1700 perror_with_name (_(
"Couldn't set general-purpose registers"));
1750 perror_with_name (_(
"Couldn't get floating-point registers"));
1762 perror_with_name (_(
"Couldn't set floating-point registers"));
1889 memset (gregsetp, 0,
sizeof (*gregsetp));
1899 fpregsetp,
sizeof (*fpregsetp));
1909 fpregsetp,
sizeof (*fpregsetp));
1914 const gdb_byte *endptr, CORE_ADDR *typep,
1924 const gdb_byte *ptr = *readptr;
1929 if (endptr - ptr < sizeof_auxv_field * 2)
1933 ptr += sizeof_auxv_field;
1935 ptr += sizeof_auxv_field;
1958 else if (errno != EIO)
1959 perror_with_name (_(
"Unable to fetch SPE registers"));
1975 features.
vsx =
true;
1979 else if (errno != EIO)
1980 perror_with_name (_(
"Unable to fetch VSX registers"));
1993 else if (errno != EIO)
1994 perror_with_name (_(
"Unable to fetch AltiVec registers"));
2015 features.
htm =
true;
2045 int total_hw_wp, total_hw_bp;
2073 if (total_hw_wp == 0)
2075 else if (cnt + ot > total_hw_wp)
2082 if (total_hw_bp == 0)
2084 else if (cnt > total_hw_bp)
2116 int region_align = region_size;
2140 && (addr + len > (addr & ~(region_align - 1)) + region_size))
2153 && (addr + len) > (addr & ~3) + 4)
2154 || (addr + len) > (addr & ~7) + 8)
2279 if (
type == hw_read)
2281 else if (
type == hw_write)
2296 target_hw_bp_type rw)
2322 target_hw_bp_type rw)
2385 CORE_ADDR data_value,
2392 int i, num_byte_enable, align_offset, num_bytes_off_dvc,
2393 rightmost_enabled_byte;
2394 CORE_ADDR addr_end_data, addr_end_dvc;
2402 addr_end_data = addr + len;
2403 addr_end_dvc = (addr - align_offset
2405 num_bytes_off_dvc = (addr_end_data > addr_end_dvc)?
2406 addr_end_data - addr_end_dvc : 0;
2407 num_byte_enable = len - num_bytes_off_dvc;
2409 rightmost_enabled_byte = (addr_end_data < addr_end_dvc)?
2410 addr_end_dvc - addr_end_data : 0;
2413 for (i = 0; i < num_byte_enable; i++)
2421 *condition_value = ((uint64_t) data_value >> num_bytes_off_dvc * 8
2422 << rightmost_enabled_byte * 8);
2435 int found_memory_cnt = 0;
2454 struct value *v = iter.get ();
2472 return found_memory_cnt;
2485 CORE_ADDR *data_value,
int *len)
2487 int num_accesses_left, num_accesses_right;
2488 struct value *left_val, *right_val;
2489 std::vector<value_ref_ptr> left_chain, right_chain;
2493 if (eqop ==
nullptr)
2501 if (left_val == NULL || num_accesses_left < 0)
2507 if (right_val == NULL || num_accesses_right < 0)
2510 if (num_accesses_left == 1 && num_accesses_right == 0
2512 && left_val->
address () == watch_addr)
2520 else if (num_accesses_left == 0 && num_accesses_right == 1
2522 && right_val->
address () == watch_addr)
2545 CORE_ADDR data_value;
2561 CORE_ADDR addr,
int len,
2562 enum target_hw_bp_type
type,
2573 CORE_ADDR data_value;
2602 p->
addr2 = (uint64_t) addr + len;
2607 p->
addr = (uint64_t) addr;
2616 enum target_hw_bp_type
type,
2637 long read_mode, write_mode;
2654 wp_value = addr & ~(read_mode | write_mode);
2659 wp_value |= read_mode;
2663 wp_value |= write_mode;
2667 wp_value |= read_mode | write_mode;
2683 enum target_hw_bp_type
type,
2721 ptid_t pid_ptid (
pid, 0, 0);
2730 if (it->first.matches (pid_ptid))
2773 ptid_t child_ptid (child_pid, child_pid, 0);
2795 ptid_t child_ptid (parent->
ptid.pid (), child_lwp, 0);
2820 if (lp_arch_info != NULL)
2826 xfree (lp_arch_info);
2859 gdb_assert (lp->
ptid.lwp_p ());
2871 auto &bp_list = installed_it->second;
2873 for (
auto bp_it = bp_list.begin (); bp_it != bp_list.end ();)
2882 if (errno != ENOENT)
2883 perror_with_name (_(
"Error deleting hardware "
2884 "breakpoint or watchpoint"));
2890 bp_it = bp_list.erase (bp_it);
2893 gdb_assert (bp_list.empty ());
2904 : process_it->second.requested_hw_bps)
2910 perror_with_name (_(
"Error setting hardware "
2911 "breakpoint or watchpoint"));
2915 bp_list.emplace (bp_list.begin (), slot,
bp);
2929 perror_with_name (_(
"Error clearing hardware watchpoint"));
2933 && process_it->second.requested_wp_val.has_value ())
2935 long wp = *(process_it->second.requested_wp_val);
2938 perror_with_name (_(
"Error setting hardware watchpoint"));
2957 if (siginfo.si_signo != SIGTRAP
2958 || (siginfo.si_code & 0xffff) != 0x0004 )
2973 int slot = siginfo.si_errno;
2981 for (
const auto & slot_bp_pair : installed_it->second)
2982 if (slot_bp_pair.first == slot
2983 && (slot_bp_pair.second.trigger_type
2988 *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
3013 return start <= addr && start + length >= addr;
3022 return start <= addr + mask && start + length - 1 >= addr;
3037 else if ((mask & 0xC0000000) != 0xC0000000)
3039 warning (_(
"The given mask covers kernel address space "
3040 "and cannot be used.\n"));
3054 const ptid_t &child_ptid)
3090 [
this] (
struct lwp_info *lp) ->
int {
3137 auto bp_it = std::find_if (process_it->second.requested_hw_bps.begin (),
3138 process_it->second.requested_hw_bps.end (),
3141 { return hwdebug_point_cmp (bp, curr); }
3145 gdb_assert (bp_it != process_it->second.requested_hw_bps.end ());
3147 process_it->second.requested_hw_bps.erase (bp_it);
3186 gdb_assert (process_it->second.requested_wp_val.has_value ());
3188 process_it->second.requested_wp_val.reset ();
struct gdbarch * target_gdbarch(void)
operation * get_rhs() const
operation * get_lhs() const
const struct ppc_debug_info & hwdebug_info()
void detect(const ptid_t &ptid)
struct ppc_debug_info m_hwdebug_info
ppc_linux_dreg_interface()
DISABLE_COPY_AND_ASSIGN(ppc_linux_dreg_interface)
gdb::optional< enum debug_reg_interface > m_interface
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void fetch_subexp_value(struct expression *exp, expr::operation *op, struct value **valp, struct value **resultp, std::vector< value_ref_ptr > *val_chain, bool preserve_errors)
#define ptrace(request, pid, addr, data)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
struct type * check_typedef(struct type *type)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
GDB_FPREGSET_T gdb_fpregset_t
GDB_GREGSET_T gdb_gregset_t
void add_inf_child_target(inf_child_target *target)
pid_t get_ptrace_pid(ptid_t ptid)
void linux_stop_lwp(struct lwp_info *lwp)
bool linux_nat_get_siginfo(ptid_t ptid, siginfo_t *siginfo)
void lwp_set_arch_private_info(struct lwp_info *lwp, struct arch_lwp_info *info)
struct arch_lwp_info * lwp_arch_private_info(struct lwp_info *lwp)
struct lwp_info * iterate_over_lwps(ptid_t filter, gdb::function_view< iterate_over_lwps_ftype > callback)
struct linux_nat_target * linux_target
int lwp_is_stopped(struct lwp_info *lwp)
CORE_ADDR linux_get_hwcap2()
CORE_ADDR linux_get_hwcap()
bool ppc_linux_has_isa205(CORE_ADDR hwcap)
const struct target_desc * ppc_linux_match_description(struct ppc_linux_features features)
#define PPC_LINUX_SIZEOF_DSCRREGSET
#define PPC_LINUX_SIZEOF_CTARREGSET
#define PPC_LINUX_SIZEOF_PPRREGSET
#define PPC64_LINUX_SIZEOF_CGPRREGSET
#define PPC_LINUX_SIZEOF_EBBREGSET
#define PPC_LINUX_SIZEOF_CPPRREGSET
#define PPC_LINUX_SIZEOF_VSXREGSET
#define PPC_LINUX_SIZEOF_CVSXREGSET
const struct ppc_linux_features ppc_linux_no_features
#define PPC32_LINUX_SIZEOF_CGPRREGSET
#define PPC_LINUX_SIZEOF_TM_SPRREGSET
#define PPC_LINUX_SIZEOF_PMUREGSET
#define PPC_LINUX_SIZEOF_CFPRREGSET
#define PPC_LINUX_SIZEOF_CDSCRREGSET
#define PPC_LINUX_SIZEOF_VRREGSET
#define PPC_LINUX_SIZEOF_CVMXREGSET
#define PPC_LINUX_SIZEOF_TARREGSET
static void store_spe_register(const struct regcache *regcache, int tid, int regno)
char gdb_vrregset_t[PPC_LINUX_SIZEOF_VRREGSET]
int have_ptrace_getsetfpregs
static void fetch_gp_regs(struct regcache *regcache, int tid)
#define PPC_DEBUG_FEATURE_DATA_BP_ARCH_31
#define PPC_PTRACE_SETHWDEBUG
int have_ptrace_getsetevrregs
#define PTRACE_SET_DEBUGREG
void supply_gregset(struct regcache *regcache, const gdb_gregset_t *gregsetp)
static int store_all_fp_regs(const struct regcache *regcache, int tid, int regno)
static void store_ppc_registers(const struct regcache *regcache, int tid)
#define PTRACE_GET_DEBUGREG
#define PPC_BREAKPOINT_MODE_MASK
static void fetch_altivec_registers(struct regcache *regcache, int tid, int regno)
char gdb_vsxregset_t[PPC_LINUX_SIZEOF_VSXREGSET]
static bool check_regset(int tid, int regset_id, int regsetsize)
int have_ptrace_getsetregs
#define PPC_BREAKPOINT_CONDITION_AND
int have_ptrace_getsetvsxregs
static void store_altivec_registers(const struct regcache *regcache, int tid, int regno)
#define PPC_BREAKPOINT_TRIGGER_READ
#define PPC_DEBUG_FEATURE_DATA_BP_MASK
static void store_regset(const struct regcache *regcache, int tid, int regnum, int regset_id, int regsetsize, const struct regset *regset)
#define PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE
#define PPC_BREAKPOINT_TRIGGER_EXECUTE
void fill_gregset(const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno)
static void fetch_fp_regs(struct regcache *regcache, int tid)
static int fetch_all_gp_regs(struct regcache *regcache, int tid)
void supply_fpregset(struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
static void fetch_regset(struct regcache *regcache, int tid, int regset_id, int regsetsize, const struct regset *regset)
int have_ptrace_getvrregs
#define PPC_DEBUG_CURRENT_VERSION
#define PPC_DEBUG_FEATURE_INSN_BP_RANGE
static int fetch_all_fp_regs(struct regcache *regcache, int tid)
static void set_spe_registers(int tid, struct gdb_evrregset_t *evrregset)
static void store_gp_regs(const struct regcache *regcache, int tid, int regno)
static void get_spe_registers(int tid, struct gdb_evrregset_t *evrregset)
static void store_fp_regs(const struct regcache *regcache, int tid, int regno)
static void store_register(const struct regcache *regcache, int tid, int regno)
static int store_all_gp_regs(const struct regcache *regcache, int tid, int regno)
void _initialize_ppc_linux_nat()
#define PPC_DEBUG_FEATURE_DATA_BP_DAWR
static int ppc_register_u_addr(struct gdbarch *gdbarch, int regno)
#define PPC_BREAKPOINT_MODE_EXACT
static void fetch_ppc_registers(struct regcache *regcache, int tid)
void fill_fpregset(const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno)
#define PPC_BREAKPOINT_CONDITION_NONE
#define PPC_DEBUG_FEATURE_DATA_BP_RANGE
static void fetch_spe_register(struct regcache *regcache, int tid, int regno)
static ppc_linux_nat_target the_ppc_linux_nat_target
#define PPC_PTRACE_GETHWDBGINFO
static void fetch_vsx_registers(struct regcache *regcache, int tid, int regno)
static void store_vsx_registers(const struct regcache *regcache, int tid, int regno)
#define PPC_PTRACE_DELHWDEBUG
#define PPC_BREAKPOINT_TRIGGER_WRITE
#define PPC_BREAKPOINT_CONDITION_BE(n)
static void fetch_register(struct regcache *regcache, int tid, int regno)
const struct regset ppc32_linux_dscrregset
const struct regset ppc32_linux_tm_sprregset
const struct regset * ppc_linux_vsxregset(void)
const struct regset * ppc_linux_fpregset(void)
const struct regset ppc32_linux_tarregset
const struct regset ppc32_linux_cfprregset
int ppc_linux_trap_reg_p(struct gdbarch *gdbarch)
const struct regset ppc32_linux_pmuregset
const struct regset * ppc_linux_gregset(int wordsize)
const struct regset ppc32_linux_cvsxregset
const struct regset ppc32_linux_pprregset
const struct regset ppc32_linux_ebbregset
const struct regset ppc32_linux_ctarregset
const struct regset ppc32_linux_cdscrregset
const struct regset * ppc_linux_cvmxregset(struct gdbarch *gdbarch)
const struct regset * ppc_linux_cgprregset(struct gdbarch *gdbarch)
const struct regset ppc32_linux_cpprregset
const struct regset * ppc_linux_vrregset(struct gdbarch *gdbarch)
const struct target_desc * tdesc_powerpc_e500l
int ppc_linux_target_wordsize(int tid)
#define PPC_FEATURE2_ARCH_2_07
#define PPC_FEATURE2_DSCR
#define PTRACE_SETEVRREGS
#define PPC_FEATURE_BOOKE
#define PTRACE_GETEVRREGS
#define PPC_FEATURE_HAS_ALTIVEC
#define PPC_FEATURE_HAS_VSX
#define PTRACE_GETVSXREGS
#define PTRACE_SETVSXREGS
void ppc_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
#define PPC_IS_EBB_REGNUM(i)
int altivec_register_p(struct gdbarch *gdbarch, int regno)
int spe_register_p(struct gdbarch *gdbarch, int regno)
void ppc_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
#define PPC_IS_TMSPR_REGNUM(i)
#define PPC_MAX_REGISTER_SIZE
#define PPC_IS_CKPTVSX_REGNUM(i)
#define PPC_IS_CKPTVMX_REGNUM(i)
#define PPC_IS_CKPTGP_REGNUM(i)
void ppc_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
#define PPC_IS_CKPTFP_REGNUM(i)
#define PPC_IS_PMU_REGNUM(i)
int vsx_register_p(struct gdbarch *gdbarch, int regno)
void ppc_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
int register_size(struct gdbarch *gdbarch, int regnum)
target_stop_reason stop_reason
uint32_t data_bp_alignment
uint32_t num_instruction_bps
uint32_t num_condition_regs
uint32_t sizeof_condition
int ppc_vsr0_upper_regnum
std::size_t operator()(const ptid_t &ptid) const
bool can_use_watchpoint_cond_accel(void)
int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
int region_ok_for_hw_watchpoint(CORE_ADDR, int) override
int check_condition(CORE_ADDR watch_addr, struct expression *cond, CORE_ADDR *data_value, int *len)
int remove_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
bool watchpoint_addr_within_range(CORE_ADDR, CORE_ADDR, int) override
bool can_accel_watchpoint_condition(CORE_ADDR, int, int, struct expression *) override
void clear_hw_breakpoint(pid_t pid, const struct ppc_hw_breakpoint &a)
ppc_linux_dreg_interface m_dreg_interface
arch_lwp_info * get_arch_lwp_info(struct lwp_info *lp)
void register_hw_breakpoint(pid_t pid, const struct ppc_hw_breakpoint &bp)
void low_new_clone(struct lwp_info *, pid_t) override
int can_use_hw_breakpoint(enum bptype, int, int) override
void low_prepare_to_resume(struct lwp_info *) override
void copy_thread_dreg_state(const ptid_t &parent_ptid, const ptid_t &child_ptid)
void low_new_fork(struct lwp_info *, pid_t) override
void mark_debug_registers_changed(pid_t pid)
void fetch_registers(struct regcache *, int) override
std::unordered_map< pid_t, ppc_linux_process_info > m_process_info
int masked_watch_num_registers(CORE_ADDR, CORE_ADDR) override
bool hwdebug_point_cmp(const struct ppc_hw_breakpoint &a, const struct ppc_hw_breakpoint &b)
int auxv_parse(const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) override
void store_registers(struct regcache *, int) override
void init_arch_lwp_info(struct lwp_info *lp)
int get_trigger_type(enum target_hw_bp_type type)
void low_forget_process(pid_t pid) override
void low_new_thread(struct lwp_info *lp) override
int num_memory_accesses(const std::vector< value_ref_ptr > &chain)
std::unordered_map< ptid_t, std::list< std::pair< long, ppc_hw_breakpoint > >, ptid_hash > m_installed_hw_bps
int insert_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
bool low_stopped_data_address(CORE_ADDR *) override
const struct target_desc * read_description() override
void calculate_dvc(CORE_ADDR addr, int len, CORE_ADDR data_value, uint32_t *condition_mode, uint64_t *condition_value)
void register_wp(pid_t pid, long wp_value)
int insert_mask_watchpoint(CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) override
bool low_stopped_by_watchpoint() override
void create_watchpoint_request(struct ppc_hw_breakpoint *p, CORE_ADDR addr, int len, enum target_hw_bp_type type, struct expression *cond, int insert)
void low_delete_thread(arch_lwp_info *) override
void mark_thread_stale(struct lwp_info *lp)
int remove_mask_watchpoint(CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) override
int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
int ranged_break_num_registers() override
std::list< struct ppc_hw_breakpoint > requested_hw_bps
gdb::optional< long > requested_wp_val
collect_regset_ftype * collect_regset
supply_regset_ftype * supply_regset
target_ops * beneath() const
virtual const struct target_desc * read_description() TARGET_DEFAULT_RETURN(NULL)
bool deprecated_modifiable() const
struct type * type() const
enum lval_type lval() const
LONGEST value_as_long(struct value *val)
gdb::ref_ptr< struct value, value_ref_policy > value_ref_ptr
@ TARGET_STOPPED_BY_WATCHPOINT
@ TARGET_STOPPED_BY_HW_BREAKPOINT