29 #include <sys/types.h>
32 #include <sys/ioctl.h>
35 #include <sys/procfs.h>
36 #include <sys/ptrace.h>
44 #include "elf/common.h"
51 #ifndef PTRACE_GET_DEBUGREG
52 #define PTRACE_GET_DEBUGREG 25
54 #ifndef PTRACE_SET_DEBUGREG
55 #define PTRACE_SET_DEBUGREG 26
57 #ifndef PTRACE_GETSIGINFO
58 #define PTRACE_GETSIGINFO 0x4202
65 #ifndef PPC_PTRACE_GETHWDBGINFO
70 #define PPC_PTRACE_GETHWDBGINFO 0x89
71 #define PPC_PTRACE_SETHWDEBUG 0x88
72 #define PPC_PTRACE_DELHWDEBUG 0x87
86 #define PPC_DEBUG_FEATURE_INSN_BP_RANGE 0x1
87 #define PPC_DEBUG_FEATURE_INSN_BP_MASK 0x2
88 #define PPC_DEBUG_FEATURE_DATA_BP_RANGE 0x4
89 #define PPC_DEBUG_FEATURE_DATA_BP_MASK 0x8
103 #define PPC_BREAKPOINT_TRIGGER_EXECUTE 0x1
104 #define PPC_BREAKPOINT_TRIGGER_READ 0x2
105 #define PPC_BREAKPOINT_TRIGGER_WRITE 0x4
106 #define PPC_BREAKPOINT_TRIGGER_RW 0x6
109 #define PPC_BREAKPOINT_MODE_EXACT 0x0
110 #define PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE 0x1
111 #define PPC_BREAKPOINT_MODE_RANGE_EXCLUSIVE 0x2
112 #define PPC_BREAKPOINT_MODE_MASK 0x3
115 #define PPC_BREAKPOINT_CONDITION_NONE 0x0
116 #define PPC_BREAKPOINT_CONDITION_AND 0x1
117 #define PPC_BREAKPOINT_CONDITION_EXACT 0x1
118 #define PPC_BREAKPOINT_CONDITION_OR 0x2
119 #define PPC_BREAKPOINT_CONDITION_AND_OR 0x3
120 #define PPC_BREAKPOINT_CONDITION_BE_ALL 0x00ff0000
121 #define PPC_BREAKPOINT_CONDITION_BE_SHIFT 16
122 #define PPC_BREAKPOINT_CONDITION_BE(n) \
123 (1<<((n)+PPC_BREAKPOINT_CONDITION_BE_SHIFT))
128 #ifndef PPC_DEBUG_FEATURE_DATA_BP_DAWR
129 #define PPC_DEBUG_FEATURE_DATA_BP_DAWR 0x10
134 #ifndef PTRACE_GETREGS
135 #define PTRACE_GETREGS 12
137 #ifndef PTRACE_SETREGS
138 #define PTRACE_SETREGS 13
140 #ifndef PTRACE_GETFPREGS
141 #define PTRACE_GETFPREGS 14
143 #ifndef PTRACE_SETFPREGS
144 #define PTRACE_SETFPREGS 15
174 #define SIZEOF_VRREGS 33*16+4
210 #define SIZEOF_VSXREGS 32*8
310 u_addr = PT_NIP * wordsize;
339 if (wordsize == 8 && PT_FPSCR == (48 + 32 + 1))
344 else if (wordsize == 4 &&
register_size (gdbarch, regno) == 8
345 && PT_FPSCR == (48 + 2*32 + 1))
346 u_addr = (48 + 2*32) * wordsize;
444 memset (evrregset, 0,
sizeof (*evrregset));
497 int bytes_transferred;
540 for (bytes_transferred = 0;
542 bytes_transferred +=
sizeof (
long))
548 regaddr +=
sizeof (
long);
552 xsnprintf (message,
sizeof (message),
"reading register %s (#%d)",
556 memcpy (&buf[bytes_transferred], &l,
sizeof (l));
572 size_t padding = (bytes_transferred -
register_size (gdbarch, regno));
577 _(
"fetch_register: unexpected byte order: %d"),
592 *vsxregsetp + i * vsxregsize);
606 for (i = 0; i < num_of_vrregs; i++)
612 if (i == (num_of_vrregs - 2))
614 *vrregsetp + i * vrregsize + offset);
617 *vrregsetp + i * vrregsize);
940 memset (&evrregs, 42,
sizeof (evrregs));
985 size_t bytes_to_transfer;
1010 memset (buf, 0,
sizeof buf);
1020 size_t padding = (bytes_to_transfer -
register_size (gdbarch, regno));
1024 for (i = 0; i < bytes_to_transfer; i +=
sizeof (
long))
1028 memcpy (&l, &buf[i],
sizeof (l));
1031 regaddr +=
sizeof (
long);
1046 xsnprintf (message,
sizeof (message),
"writing register %s (#%d)",
1063 *vsxregsetp + i * vsxregsize);
1076 for (i = 0; i < num_of_vrregs; i++)
1080 if (i == (num_of_vrregs - 2))
1082 *vrregsetp + i * vrregsize + offset);
1085 *vrregsetp + i * vrregsize);
1302 static unsigned long
1308 return (
unsigned long) field;
1354 #define PPC_DEBUG_CURRENT_VERSION 1
1358 have_ptrace_hwdebug_interface (
void)
1360 static int have_ptrace_hwdebug_interface = -1;
1362 if (have_ptrace_hwdebug_interface == -1)
1377 have_ptrace_hwdebug_interface = 1;
1381 return have_ptrace_hwdebug_interface;
1385 have_ptrace_hwdebug_interface = 0;
1389 return have_ptrace_hwdebug_interface;
1394 int type,
int cnt,
int ot)
1396 int total_hw_wp, total_hw_bp;
1398 if (have_ptrace_hwdebug_interface ())
1417 if (cnt + ot > total_hw_wp)
1422 if (total_hw_bp == 0)
1427 if (cnt > total_hw_bp)
1431 if (!have_ptrace_hwdebug_interface ())
1462 if (have_ptrace_hwdebug_interface ())
1483 && (addr + len > (addr & ~(region_size - 1)) + region_size))
1492 && (addr + len) > (addr & ~3) + 4)
1493 || (addr + len) > (addr & ~7) + 8)
1606 if (errno != ENOENT)
1608 "breakpoint or watchpoint"));
1610 xfree (hw_breaks[i].hw_break);
1619 return ((have_ptrace_hwdebug_interface ()
1635 if (!have_ptrace_hwdebug_interface ())
1672 if (!have_ptrace_hwdebug_interface ())
1728 gdb_assert (have_ptrace_hwdebug_interface ());
1756 gdb_assert (have_ptrace_hwdebug_interface ());
1781 if (!have_ptrace_hwdebug_interface () || cnt == 0)
1812 uint32_t *condition_mode, uint64_t *condition_value)
1814 int i, num_byte_enable, align_offset, num_bytes_off_dvc,
1815 rightmost_enabled_byte;
1824 addr_end_data = addr +
len;
1825 addr_end_dvc = (addr - align_offset
1827 num_bytes_off_dvc = (addr_end_data > addr_end_dvc)?
1828 addr_end_data - addr_end_dvc : 0;
1829 num_byte_enable = len - num_bytes_off_dvc;
1831 rightmost_enabled_byte = (addr_end_data < addr_end_dvc)?
1832 addr_end_dvc - addr_end_data : 0;
1835 for (i = 0; i < num_byte_enable; i++)
1843 *condition_value = ((uint64_t) data_value >> num_bytes_off_dvc * 8
1844 << rightmost_enabled_byte * 8);
1855 int found_memory_cnt = 0;
1856 struct value *head = v;
1891 return found_memory_cnt;
1904 int pc = 1, num_accesses_left, num_accesses_right;
1905 struct value *left_val, *right_val, *left_chain, *right_chain;
1913 if (left_val == NULL || num_accesses_left < 0)
1923 if (right_val == NULL || num_accesses_right < 0)
1931 if (num_accesses_left == 1 && num_accesses_right == 0
1941 else if (num_accesses_left == 0 && num_accesses_right == 1
1975 return (have_ptrace_hwdebug_interface ()
2023 p->
addr2 = (uint64_t) addr + len;
2028 p->
addr = (uint64_t) addr;
2039 if (have_ptrace_hwdebug_interface ())
2053 long read_mode, write_mode;
2070 dabr_value = addr & ~(read_mode | write_mode);
2075 dabr_value |= read_mode;
2079 dabr_value |= write_mode;
2083 dabr_value |= read_mode | write_mode;
2108 if (have_ptrace_hwdebug_interface ())
2138 if (have_ptrace_hwdebug_interface ())
2179 if (!have_ptrace_hwdebug_interface ())
2197 if (hw_breaks[i].hw_break)
2198 xfree (hw_breaks[i].hw_break);
2212 if (siginfo.si_signo != SIGTRAP
2213 || (siginfo.si_code & 0xffff) != 0x0004 )
2216 if (have_ptrace_hwdebug_interface ())
2222 int slot = siginfo.si_errno;
2232 if (hw_breaks[i].
hw_break && hw_breaks[i].slot == slot
2239 *addr_p = (
CORE_ADDR) (uintptr_t) siginfo.si_addr;
2257 if (have_ptrace_hwdebug_interface ()
2259 return start <= addr && start + length >= addr;
2268 return start <= addr + mask && start + length - 1 >= addr;
2277 if (!have_ptrace_hwdebug_interface ()
2280 else if ((mask & 0xC0000000) != 0xC0000000)
2282 warning (
_(
"The given mask covers kernel address space "
2283 "and cannot be used.\n"));
2329 memset (gregsetp, 0,
sizeof (*gregsetp));
2339 fpregsetp,
sizeof (*fpregsetp));
2349 fpregsetp,
sizeof (*fpregsetp));
2359 #ifdef __powerpc64__
2367 msr = (
long)
ptrace (PTRACE_PEEKUSER, tid, PT_MSR * 8, 0);
2368 if (errno == 0 && ppc64_64bit_inferior_p (msr))
2386 if (endptr - ptr < sizeof_auxv_field * 2)
2390 ptr += sizeof_auxv_field;
2392 ptr += sizeof_auxv_field;
2419 else if (errno != EIO)
2432 else if (errno != EIO)
2445 else if (errno != EIO)
struct gdbarch * target_gdbarch(void)
union exp_element elts[1]
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
uint32_t num_condition_regs
static int ppc_linux_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR addr, int len, int rw, struct expression *cond)
#define PTRACE_SET_DEBUGREG
#define PPC_PTRACE_GETHWDBGINFO
struct ppc_hw_breakpoint * hw_break
static void hwdebug_remove_point(struct ppc_hw_breakpoint *b, int tid)
static int ppc_linux_insert_watchpoint(struct target_ops *self, CORE_ADDR addr, int len, int rw, struct expression *cond)
static void ppc_linux_new_thread(struct lwp_info *lp)
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
const struct target_desc *(* to_read_description)(struct target_ops *ops) TARGET_DEFAULT_RETURN(NULL)
static void supply_vsxregset(struct regcache *regcache, gdb_vsxregset_t *vsxregsetp)
int have_ptrace_getsetevrregs
static int hwdebug_point_cmp(struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b)
static int fetch_all_gp_regs(struct regcache *regcache, int tid)
uint32_t sizeof_condition
struct thread_points * thread_points_p
static int ppc_linux_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
static int can_use_watchpoint_cond_accel(void)
static void fill_vrregset(const struct regcache *regcache, gdb_vrregset_t *vrregsetp)
static void store_vsx_registers(const struct regcache *regcache, int tid)
struct target_desc * tdesc_powerpc_isa205_vsx32l
static int ppc_linux_can_use_hw_breakpoint(struct target_ops *self, int type, int cnt, int ot)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
LONGEST value_as_long(struct value *val)
void linux_nat_set_new_thread(struct target_ops *t, void(*new_thread)(struct lwp_info *))
void ppc_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
void warning(const char *fmt,...)
const struct regset * gregset
static void fetch_gp_regs(struct regcache *regcache, int tid)
struct target_desc * tdesc_powerpc_e500l
static void store_altivec_registers(const struct regcache *regcache, int tid)
void internal_error(const char *file, int line, const char *fmt,...)
static int store_all_fp_regs(const struct regcache *regcache, int tid, int regno)
static struct ppc_debug_info hwdebug_info
int have_ptrace_getsetvsxregs
#define VEC_unordered_remove(T, V, I)
static int ppc_register_u_addr(struct gdbarch *gdbarch, int regno)
static void supply_vrregset(struct regcache *regcache, gdb_vrregset_t *vrregsetp)
static int ppc_linux_insert_mask_watchpoint(struct target_ops *ops, CORE_ADDR addr, CORE_ADDR mask, int rw)
struct target_desc * tdesc_powerpc_32l
struct target_desc * tdesc_powerpc_isa205_64l
#define VEC_safe_push(T, V, O)
#define PTRACE_GETEVRREGS
static void ppc_linux_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
const struct regset * ppc_linux_gregset(int wordsize)
int(* to_region_ok_for_hw_watchpoint)(struct target_ops *, CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_region_ok_for_hw_watchpoint)
static int ppc_linux_stopped_data_address(struct target_ops *target, CORE_ADDR *addr_p)
void _initialize_ppc_linux_nat(void)
static int ppc_linux_masked_watch_num_registers(struct target_ops *target, CORE_ADDR addr, CORE_ADDR mask)
int vsx_register_p(struct gdbarch *gdbarch, int regno)
int linux_nat_get_siginfo(ptid_t ptid, siginfo_t *siginfo)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
void supply_gregset(struct regcache *regcache, const gdb_gregset_t *gregsetp)
#define PPC_BREAKPOINT_MODE_MASK
struct target_desc * tdesc_powerpc_cell32l
static void fetch_spe_register(struct regcache *regcache, int tid, int regno)
#define PPC_DEBUG_FEATURE_DATA_BP_DAWR
static int ppc_linux_ranged_break_num_registers(struct target_ops *target)
static const struct target_desc * ppc_linux_read_description(struct target_ops *ops)
static int check_condition(CORE_ADDR watch_addr, struct expression *cond, CORE_ADDR *data_value, int *len)
static int get_trigger_type(int rw)
struct target_desc * tdesc_powerpc_64l
static int ppc_linux_remove_mask_watchpoint(struct target_ops *ops, CORE_ADDR addr, CORE_ADDR mask, int rw)
#define PPC_FEATURE_HAS_DFP
static int num_memory_accesses(struct value *v)
void free_value_chain(struct value *v)
int(* to_insert_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
#define VEC_iterate(T, V, I, P)
static size_t max_slots_number
struct type * check_typedef(struct type *type)
void ppc_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
int ppc_vsr0_upper_regnum
struct target_desc * tdesc_powerpc_cell64l
#define PPC_DEBUG_FEATURE_DATA_BP_RANGE
#define PTRACE_SETEVRREGS
static void store_fp_regs(const struct regcache *regcache, int tid, int regno)
struct target_ops current_target
static void fetch_altivec_registers(struct regcache *regcache, int tid)
int value_lazy(struct value *value)
#define PPC_PTRACE_SETHWDEBUG
struct target_desc * tdesc_powerpc_altivec32l
#define PPC_BREAKPOINT_CONDITION_AND
#define PPC_BREAKPOINT_TRIGGER_READ
int(* to_watchpoint_addr_within_range)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_watchpoint_addr_within_range)
uint32_t data_bp_alignment
void * xzalloc(size_t size)
#define PPC_BREAKPOINT_MODE_EXACT
GDB_GREGSET_T gdb_gregset_t
static struct thread_points * hwdebug_find_thread_points_by_tid(int tid, int alloc_new)
int(* to_remove_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
#define PPC_FEATURE_BOOKE
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
int ppc_linux_trap_reg_p(struct gdbarch *gdbarch)
static void fetch_register(struct regcache *regcache, int tid, int regno)
static void calculate_dvc(CORE_ADDR addr, int len, CORE_ADDR data_value, uint32_t *condition_mode, uint64_t *condition_value)
int have_ptrace_getvrregs
GDB_FPREGSET_T gdb_fpregset_t
static void set_spe_registers(int tid, struct gdb_evrregset_t *evrregset)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
static int fetch_all_fp_regs(struct regcache *regcache, int tid)
void fill_fpregset(const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
#define PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE
int(* to_masked_watch_num_registers)(struct target_ops *, CORE_ADDR, CORE_ADDR) TARGET_DEFAULT_RETURN(-1)
#define PPC_BREAKPOINT_TRIGGER_WRITE
static int store_all_gp_regs(const struct regcache *regcache, int tid, int regno)
#define PPC_PTRACE_DELHWDEBUG
static void get_spe_registers(int tid, struct gdb_evrregset_t *evrregset)
static int ppc_linux_watchpoint_addr_within_range(struct target_ops *target, CORE_ADDR addr, CORE_ADDR start, int length)
static long saved_dabr_value
char gdb_vrregset_t[SIZEOF_VRREGS]
struct target_desc * tdesc_powerpc_isa205_altivec64l
void ppc_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
void linux_nat_add_target(struct target_ops *t)
static void fetch_ppc_registers(struct regcache *regcache, int tid)
static int ppc_linux_stopped_by_watchpoint(struct target_ops *ops)
static void fetch_altivec_register(struct regcache *regcache, int tid, int regno)
struct value * value_next(struct value *value)
int deprecated_value_modifiable(struct value *value)
static int ppc_linux_remove_watchpoint(struct target_ops *self, CORE_ADDR addr, int len, int rw, struct expression *cond)
struct target_ops * linux_target(void)
int(* to_insert_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
int(* to_remove_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
static void ppc_linux_thread_exit(struct thread_info *tp, int silent)
#define PPC_DEBUG_FEATURE_DATA_BP_MASK
int have_ptrace_getsetfpregs
int ptid_get_pid(ptid_t ptid)
const struct regset * ppc_linux_fpregset(void)
static void ppc_linux_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
int(* to_auxv_parse)(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) TARGET_DEFAULT_FUNC(default_auxv_parse)
int(* to_remove_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
void fetch_subexp_value(struct expression *exp, int *pc, struct value **valp, struct value **resultp, struct value **val_chain, int preserve_errors)
int have_ptrace_getsetregs
void discard_cleanups(struct cleanup *old_chain)
ULONGEST align_up(ULONGEST v, int n)
static unsigned long ppc_linux_get_hwcap(void)
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
static int ppc_linux_target_wordsize(void)
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
static void fetch_fp_regs(struct regcache *regcache, int tid)
int(* to_can_use_hw_breakpoint)(struct target_ops *, int, int, int) TARGET_DEFAULT_RETURN(0)
int xsnprintf(char *str, size_t size, const char *format,...)
struct hw_break_tuple * hw_breaks
static void fill_vsxregset(const struct regcache *regcache, gdb_vsxregset_t *vsxregsetp)
int(* to_can_accel_watchpoint_condition)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(0)
static void store_spe_register(const struct regcache *regcache, int tid, int regno)
static void store_gp_regs(const struct regcache *regcache, int tid, int regno)
static void create_watchpoint_request(struct ppc_hw_breakpoint *p, CORE_ADDR addr, int len, int rw, struct expression *cond, int insert)
#define PPC_DEBUG_FEATURE_INSN_BP_RANGE
#define PTRACE_GETVSXREGS
int(* to_ranged_break_num_registers)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
struct m32c_reg regs[M32C_MAX_NUM_REGS]
struct target_desc * tdesc_powerpc_isa205_32l
void supply_fpregset(struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
#define PPC_DEBUG_CURRENT_VERSION
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
struct target_desc * tdesc_powerpc_vsx64l
static int ppc_linux_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
int register_size(struct gdbarch *gdbarch, int regnum)
long ptid_get_lwp(ptid_t ptid)
struct type * value_type(const struct value *value)
struct target_desc * tdesc_powerpc_vsx32l
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
struct target_desc * tdesc_powerpc_isa205_vsx64l
static void store_ppc_registers(const struct regcache *regcache, int tid)
#define PTRACE_SETVSXREGS
#define TYPE_LENGTH(thistype)
int altivec_register_p(struct gdbarch *gdbarch, int regno)
static void store_register(const struct regcache *regcache, int tid, int regno)
static void fetch_vsx_registers(struct regcache *regcache, int tid)
int spe_register_p(struct gdbarch *gdbarch, int regno)
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
static void store_vsx_register(const struct regcache *regcache, int tid, int regno)
CORE_ADDR value_address(const struct value *value)
struct target_desc * tdesc_powerpc_altivec64l
static void hwdebug_insert_point(struct ppc_hw_breakpoint *b, int tid)
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
#define PPC_BREAKPOINT_TRIGGER_EXECUTE
static int ppc_linux_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
static int ppc_linux_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
uint32_t num_instruction_bps
int(* to_insert_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
static void store_altivec_register(const struct regcache *regcache, int tid, int regno)
void ppc_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
#define PPC_BREAKPOINT_CONDITION_BE(n)
struct target_desc * tdesc_powerpc_isa205_altivec32l
DEF_VEC_P(thread_points_p)
static void fetch_vsx_register(struct regcache *regcache, int tid, int regno)
const ULONGEST const LONGEST len
char gdb_vsxregset_t[SIZEOF_VSXREGS]
#define PPC_BREAKPOINT_CONDITION_NONE
void fill_gregset(const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno)