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
383 gdb_assert (ptid.lwp_p ());
385 bool no_features =
false;
430 if (no_features || errno == EIO)
442 warning (_(
"Error when detecting the debug register interface. "
443 "Debug registers will be unavailable."));
534 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
557 const ptid_t &child_ptid);
576 CORE_ADDR data_value,
577 uint32_t *condition_mode,
578 uint64_t *condition_value);
582 CORE_ADDR *data_value,
int *len);
591 enum target_hw_bp_type
type,
615 return std::hash<long>{} (ptid.lwp ());
624 std::unordered_map <ptid_t,
625 std::list<std::pair<long, ppc_hw_breakpoint>>,
655 int wordsize =
sizeof (long);
668 u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->
ppc_fp0_regnum) * 8);
672 u_addr = PT_NIP * wordsize;
674 u_addr = PT_LNK * wordsize;
676 u_addr = PT_CCR * wordsize;
678 u_addr = PT_XER * wordsize;
680 u_addr = PT_CTR * wordsize;
683 u_addr = PT_MQ * wordsize;
686 u_addr = PT_MSR * wordsize;
701 if (wordsize == 8 && PT_FPSCR == (48 + 32 + 1))
702 u_addr = (48 + 32) * wordsize;
707 && PT_FPSCR == (48 + 2*32 + 1))
708 u_addr = (48 + 2*32) * wordsize;
710 u_addr = PT_FPSCR * wordsize;
794 memset (evrregset, 0,
sizeof (*evrregset));
808 gdb_assert (
sizeof (evrregs.
evr[0])
810 gdb_assert (
sizeof (evrregs.
acc)
812 gdb_assert (
sizeof (evrregs.
spefscr)
846 int regset_id,
int regsetsize,
const struct regset *
regset)
848 void *buf = alloca (regsetsize);
852 iov.iov_len = regsetsize;
856 if (errno == ENODATA)
872 int regset_id,
int regsetsize,
const struct regset *
regset)
874 void *buf = alloca (regsetsize);
878 iov.iov_len = regsetsize;
897 void *buf = alloca (regsetsize);
901 iov.iov_len = regsetsize;
917 int bytes_transferred;
1080 for (bytes_transferred = 0;
1082 bytes_transferred +=
sizeof (long))
1088 regaddr +=
sizeof (long);
1092 xsnprintf (message,
sizeof (message),
"reading register %s (#%d)",
1096 memcpy (&buf[bytes_transferred], &l,
sizeof (l));
1116 internal_error (_(
"fetch_register: unexpected byte order: %d"),
1430 gdb_assert (
sizeof (evrregs.
evr[0])
1432 gdb_assert (
sizeof (evrregs.
acc)
1434 gdb_assert (
sizeof (evrregs.
spefscr)
1441 memset (&evrregs, 42,
sizeof (evrregs));
1483 size_t bytes_to_transfer;
1629 memset (buf, 0,
sizeof buf);
1643 for (i = 0; i < bytes_to_transfer; i +=
sizeof (long))
1647 memcpy (&l, &buf[i],
sizeof (l));
1650 regaddr +=
sizeof (long);
1665 xsnprintf (message,
sizeof (message),
"writing register %s (#%d)",
1893 memset (gregsetp, 0,
sizeof (*gregsetp));
1903 fpregsetp,
sizeof (*fpregsetp));
1913 fpregsetp,
sizeof (*fpregsetp));
1918 const gdb_byte *endptr, CORE_ADDR *typep,
1928 const gdb_byte *ptr = *readptr;
1933 if (endptr - ptr < sizeof_auxv_field * 2)
1937 ptr += sizeof_auxv_field;
1939 ptr += sizeof_auxv_field;
1959 else if (errno != EIO)
1976 features.
vsx =
true;
1980 else if (errno != EIO)
1994 else if (errno != EIO)
2016 features.
htm =
true;
2046 int total_hw_wp, total_hw_bp;
2074 if (total_hw_wp == 0)
2076 else if (cnt + ot > total_hw_wp)
2083 if (total_hw_bp == 0)
2085 else if (cnt > total_hw_bp)
2117 int region_align = region_size;
2141 && (addr + len > (addr & ~(region_align - 1)) + region_size))
2154 && (addr + len) > (addr & ~3) + 4)
2155 || (addr + len) > (addr & ~7) + 8)
2280 if (
type == hw_read)
2282 else if (
type == hw_write)
2297 target_hw_bp_type rw)
2323 target_hw_bp_type rw)
2386 CORE_ADDR data_value,
2393 int i, num_byte_enable, align_offset, num_bytes_off_dvc,
2394 rightmost_enabled_byte;
2395 CORE_ADDR addr_end_data, addr_end_dvc;
2403 addr_end_data = addr + len;
2404 addr_end_dvc = (addr - align_offset
2406 num_bytes_off_dvc = (addr_end_data > addr_end_dvc)?
2407 addr_end_data - addr_end_dvc : 0;
2408 num_byte_enable = len - num_bytes_off_dvc;
2410 rightmost_enabled_byte = (addr_end_data < addr_end_dvc)?
2411 addr_end_dvc - addr_end_data : 0;
2414 for (i = 0; i < num_byte_enable; i++)
2422 *condition_value = ((uint64_t) data_value >> num_bytes_off_dvc * 8
2423 << rightmost_enabled_byte * 8);
2436 int found_memory_cnt = 0;
2455 struct value *v = iter.get ();
2473 return found_memory_cnt;
2486 CORE_ADDR *data_value,
int *len)
2488 int num_accesses_left, num_accesses_right;
2489 struct value *left_val, *right_val;
2490 std::vector<value_ref_ptr> left_chain, right_chain;
2494 if (eqop ==
nullptr)
2502 if (left_val == NULL || num_accesses_left < 0)
2508 if (right_val == NULL || num_accesses_right < 0)
2511 if (num_accesses_left == 1 && num_accesses_right == 0
2521 else if (num_accesses_left == 0 && num_accesses_right == 1
2546 CORE_ADDR data_value;
2562 CORE_ADDR addr,
int len,
2563 enum target_hw_bp_type
type,
2574 CORE_ADDR data_value;
2603 p->
addr2 = (uint64_t) addr + len;
2608 p->
addr = (uint64_t) addr;
2617 enum target_hw_bp_type
type,
2638 long read_mode, write_mode;
2655 wp_value = addr & ~(read_mode | write_mode);
2660 wp_value |= read_mode;
2664 wp_value |= write_mode;
2668 wp_value |= read_mode | write_mode;
2684 enum target_hw_bp_type
type,
2722 ptid_t pid_ptid (
pid, 0, 0);
2731 if (it->first.matches (pid_ptid))
2774 ptid_t child_ptid (child_pid, child_pid, 0);
2796 ptid_t child_ptid (parent->
ptid.pid (), child_lwp, 0);
2821 if (lp_arch_info != NULL)
2827 xfree (lp_arch_info);
2860 gdb_assert (lp->
ptid.lwp_p ());
2872 auto &bp_list = installed_it->second;
2874 for (
auto bp_it = bp_list.begin (); bp_it != bp_list.end ();)
2883 if (errno != ENOENT)
2885 "breakpoint or watchpoint"));
2891 bp_it = bp_list.erase (bp_it);
2894 gdb_assert (bp_list.empty ());
2905 : process_it->second.requested_hw_bps)
2912 "breakpoint or watchpoint"));
2916 bp_list.emplace (bp_list.begin (), slot,
bp);
2934 && process_it->second.requested_wp_val.has_value ())
2936 long wp = *(process_it->second.requested_wp_val);
2958 if (siginfo.si_signo != SIGTRAP
2959 || (siginfo.si_code & 0xffff) != 0x0004 )
2974 int slot = siginfo.si_errno;
2982 for (
const auto & slot_bp_pair : installed_it->second)
2983 if (slot_bp_pair.first == slot
2984 && (slot_bp_pair.second.trigger_type
2989 *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
3014 return start <= addr && start + length >= addr;
3023 return start <= addr + mask && start + length - 1 >= addr;
3038 else if ((mask & 0xC0000000) != 0xC0000000)
3040 warning (_(
"The given mask covers kernel address space "
3041 "and cannot be used.\n"));
3055 const ptid_t &child_ptid)
3091 [
this] (
struct lwp_info *lp) ->
int {
3138 auto bp_it = std::find_if (process_it->second.requested_hw_bps.begin (),
3139 process_it->second.requested_hw_bps.end (),
3142 { return hwdebug_point_cmp (bp, curr); }
3146 gdb_assert (bp_it != process_it->second.requested_hw_bps.end ());
3148 process_it->second.requested_hw_bps.erase (bp_it);
3187 gdb_assert (process_it->second.requested_wp_val.has_value ());
3189 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
void perror_with_name(const char *string)
struct type * value_type(const struct value *value)
int value_lazy(const struct value *value)
CORE_ADDR value_address(const struct value *value)
LONGEST value_as_long(struct value *val)
int deprecated_value_modifiable(const struct value *value)
gdb::ref_ptr< struct value, value_ref_policy > value_ref_ptr
@ TARGET_STOPPED_BY_WATCHPOINT
@ TARGET_STOPPED_BY_HW_BREAKPOINT