62 x86_thread_state_t gp_regs;
63 unsigned int gp_count = x86_THREAD_STATE_COUNT;
66 ret = thread_get_state
67 (current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
69 if (ret != KERN_SUCCESS)
72 "GP registers for thread 0x%lx\n"),
73 (
unsigned long) current_thread);
78 gp_regs.uts.ts64.__fs &= 0xffff;
79 gp_regs.uts.ts64.__gs &= 0xffff;
87 x86_float_state_t fp_regs;
88 unsigned int fp_count = x86_FLOAT_STATE_COUNT;
91 ret = thread_get_state
92 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
94 if (ret != KERN_SUCCESS)
97 "float registers for thread 0x%lx\n"),
98 (
unsigned long) current_thread);
110 x86_thread_state32_t gp_regs;
111 unsigned int gp_count = x86_THREAD_STATE32_COUNT;
115 ret = thread_get_state
116 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
118 if (ret != KERN_SUCCESS)
121 "GP registers for thread 0x%lx\n"),
122 (
unsigned long) current_thread);
136 x86_float_state32_t fp_regs;
137 unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
140 ret = thread_get_state
141 (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs,
143 if (ret != KERN_SUCCESS)
146 "float registers for thread 0x%lx\n"),
147 (
unsigned long) current_thread);
157 warning (
_(
"unknown register %d"), regno);
178 x86_thread_state_t gp_regs;
180 unsigned int gp_count = x86_THREAD_STATE_COUNT;
182 ret = thread_get_state
183 (current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
186 gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
187 gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);
192 gp_regs.uts.ts64.__fs &= 0xffff;
193 gp_regs.uts.ts64.__gs &= 0xffff;
195 ret = thread_set_state (current_thread, x86_THREAD_STATE,
196 (thread_state_t) &gp_regs,
197 x86_THREAD_STATE_COUNT);
203 x86_float_state_t fp_regs;
205 unsigned int fp_count = x86_FLOAT_STATE_COUNT;
207 ret = thread_get_state
208 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
211 gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
212 gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);
216 ret = thread_set_state (current_thread, x86_FLOAT_STATE,
217 (thread_state_t) & fp_regs,
218 x86_FLOAT_STATE_COUNT);
227 x86_thread_state32_t gp_regs;
229 unsigned int gp_count = x86_THREAD_STATE32_COUNT;
232 ret = thread_get_state
233 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
238 if (regno == -1 || regno == i)
243 ret = thread_set_state (current_thread, x86_THREAD_STATE32,
244 (thread_state_t) &gp_regs,
245 x86_THREAD_STATE32_COUNT);
252 x86_float_state32_t fp_regs;
253 unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
256 ret = thread_get_state
257 (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
263 ret = thread_set_state (current_thread, x86_FLOAT_STATE32,
264 (thread_state_t) &fp_regs,
265 x86_FLOAT_STATE32_COUNT);
278 x86_debug_state_t dr_regs;
280 unsigned int dr_count;
286 dr_regs.dsh.flavor = x86_DEBUG_STATE;
287 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
288 dr_count = x86_DEBUG_STATE_COUNT;
289 ret = thread_get_state (current_thread, x86_DEBUG_STATE,
290 (thread_state_t) &dr_regs, &dr_count);
293 switch (dr_regs.dsh.flavor)
295 case x86_DEBUG_STATE32:
299 dr_regs.uds.ds32.__dr0 = value;
302 dr_regs.uds.ds32.__dr1 = value;
305 dr_regs.uds.ds32.__dr2 = value;
308 dr_regs.uds.ds32.__dr3 = value;
311 dr_regs.uds.ds32.__dr4 = value;
314 dr_regs.uds.ds32.__dr5 = value;
317 dr_regs.uds.ds32.__dr6 = value;
320 dr_regs.uds.ds32.__dr7 = value;
325 case x86_DEBUG_STATE64:
329 dr_regs.uds.ds64.__dr0 = value;
332 dr_regs.uds.ds64.__dr1 = value;
335 dr_regs.uds.ds64.__dr2 = value;
338 dr_regs.uds.ds64.__dr3 = value;
341 dr_regs.uds.ds64.__dr4 = value;
344 dr_regs.uds.ds64.__dr5 = value;
347 dr_regs.uds.ds64.__dr6 = value;
350 dr_regs.uds.ds64.__dr7 = value;
357 ret = thread_set_state (current_thread, dr_regs.dsh.flavor,
358 (thread_state_t) &dr_regs.uds, dr_count);
367 x86_debug_state_t dr_regs;
369 unsigned int dr_count;
375 dr_regs.dsh.flavor = x86_DEBUG_STATE;
376 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
377 dr_count = x86_DEBUG_STATE_COUNT;
378 ret = thread_get_state (current_thread, x86_DEBUG_STATE,
379 (thread_state_t) &dr_regs, &dr_count);
382 switch (dr_regs.dsh.flavor)
384 case x86_DEBUG_STATE32:
388 return dr_regs.uds.ds32.__dr0;
390 return dr_regs.uds.ds32.__dr1;
392 return dr_regs.uds.ds32.__dr2;
394 return dr_regs.uds.ds32.__dr3;
396 return dr_regs.uds.ds32.__dr4;
398 return dr_regs.uds.ds32.__dr5;
400 return dr_regs.uds.ds32.__dr6;
402 return dr_regs.uds.ds32.__dr7;
408 case x86_DEBUG_STATE64:
412 return dr_regs.uds.ds64.__dr0;
414 return dr_regs.uds.ds64.__dr1;
416 return dr_regs.uds.ds64.__dr2;
418 return dr_regs.uds.ds64.__dr3;
420 return dr_regs.uds.ds64.__dr4;
422 return dr_regs.uds.ds64.__dr5;
424 return dr_regs.uds.ds64.__dr6;
426 return dr_regs.uds.ds64.__dr7;
475 x86_thread_state_t gp_regs;
477 unsigned int gp_count = x86_THREAD_STATE_COUNT;
480 ret = thread_get_state (thread, x86_THREAD_STATE,
481 (thread_state_t) &gp_regs, &gp_count);
482 if (ret != KERN_SUCCESS)
492 if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
502 #define X86_EFLAGS_T 0x100UL
515 static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 };
516 gdb_byte buf[
sizeof (darwin_syscall)];
520 && memcmp (buf, darwin_syscall,
sizeof (darwin_syscall)) == 0
521 && regs->uts.ts32.__eax == 0xb8 )
529 (regs->uts.ts32.__esp + 4, 4, byte_order);
531 (uctx_addr + 28, 4, byte_order);
533 flags_addr = mctx_addr + 12 + 9 * 4;
545 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
548 static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 };
549 gdb_byte buf[
sizeof (darwin_syscall)];
553 && memcmp (buf, darwin_syscall,
sizeof (darwin_syscall)) == 0
554 && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 )
561 (regs->uts.ts64.__rdi + 48, 8, byte_order);
562 flags_addr = mctx_addr + 16 + 17 * 8;
578 x86_thread_state_t regs;
579 unsigned int count = x86_THREAD_STATE_COUNT;
582 kret = thread_get_state (thread, x86_THREAD_STATE,
583 (thread_state_t) ®s, &count);
584 if (kret != KERN_SUCCESS)
591 switch (regs.tsh.flavor)
593 case x86_THREAD_STATE32:
601 regs.uts.ts32.__eflags
603 kret = thread_set_state (thread, x86_THREAD_STATE,
604 (thread_state_t) ®s, count);
609 case x86_THREAD_STATE64:
613 if (enable && amd64_darwin_sstep_at_sigreturn (®s))
617 regs.uts.ts64.__rflags
619 kret = thread_set_state (thread, x86_THREAD_STATE,
620 (thread_state_t) ®s, count);
626 error (
_(
"darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
struct gdbarch * target_gdbarch(void)
static CORE_ADDR i386_darwin_dr_get(int regnum)
void darwin_complete_target(struct target_ops *target)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
static void i386_darwin_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void amd64_collect_native_gregset(const struct regcache *regcache, void *gregs, int regnum)
void gdbarch_info_fill(struct gdbarch_info *info)
void warning(const char *fmt,...)
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
static void i386_darwin_dr_set_addr(int regnum, CORE_ADDR addr)
#define I386_SSE_NUM_REGS
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
int amd64_native_gregset32_num_regs
int gdbarch_update_p(struct gdbarch_info info)
static unsigned long i386_darwin_dr_get_control(void)
const struct bfd_arch_info * bfd_arch_info
static void i386_darwin_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void(* set_control)(unsigned long)
struct x86_dr_low_type x86_dr_low
static void i386_darwin_dr_set_control(unsigned long control)
CORE_ADDR(* get_addr)(int)
static void i386_darwin_dr_set(int regnum, CORE_ADDR value)
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
#define MACH_CHECK_ERROR(ret)
static unsigned long i386_darwin_dr_get_status(void)
int amd64_native_gregset64_num_regs
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
void amd64_supply_native_gregset(struct regcache *regcache, const void *gregs, int regnum)
int * amd64_native_gregset32_reg_offset
void(* set_addr)(int, CORE_ADDR)
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
unsigned long(* get_status)(void)
int * amd64_native_gregset64_reg_offset
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void printf_unfiltered(const char *format,...)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
unsigned long(* get_control)(void)
const int amd64_darwin_thread_state_num_regs
static CORE_ADDR i386_darwin_dr_get_addr(int regnum)
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
long ptid_get_tid(ptid_t ptid)
void darwin_set_sstep(thread_t thread, int enable)
const int i386_darwin_thread_state_num_regs
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void gdbarch_info_init(struct gdbarch_info *info)
int amd64_native_gregset_supplies_p(struct gdbarch *gdbarch, int regnum)
int amd64_darwin_thread_state_reg_offset[]
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
unsigned long long ULONGEST
void x86_set_debug_register_length(int len)
int i386_darwin_thread_state_reg_offset[]
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
void x86_use_watchpoints(struct target_ops *t)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static windows_thread_info * current_thread
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
enum bfd_endian byte_order
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
void error(const char *fmt,...)
static int i386_darwin_sstep_at_sigreturn(x86_thread_state_t *regs)