71 x86_thread_state_t gp_regs;
72 unsigned int gp_count = x86_THREAD_STATE_COUNT;
75 ret = thread_get_state
76 (current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
78 if (ret != KERN_SUCCESS)
80 warning (_(
"Error calling thread_get_state for "
81 "GP registers for thread 0x%lx\n"),
82 (
unsigned long) current_thread);
87 gp_regs.uts.ts64.__fs &= 0xffff;
88 gp_regs.uts.ts64.__gs &= 0xffff;
96 x86_float_state_t fp_regs;
97 unsigned int fp_count = x86_FLOAT_STATE_COUNT;
100 ret = thread_get_state
101 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
103 if (ret != KERN_SUCCESS)
105 warning (_(
"Error calling thread_get_state for "
106 "float registers for thread 0x%lx\n"),
107 (
unsigned long) current_thread);
119 x86_thread_state32_t gp_regs;
120 unsigned int gp_count = x86_THREAD_STATE32_COUNT;
124 ret = thread_get_state
125 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
127 if (ret != KERN_SUCCESS)
129 warning (_(
"Error calling thread_get_state for "
130 "GP registers for thread 0x%lx\n"),
131 (
unsigned long) current_thread);
144 x86_float_state32_t fp_regs;
145 unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
148 ret = thread_get_state
149 (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs,
151 if (ret != KERN_SUCCESS)
153 warning (_(
"Error calling thread_get_state for "
154 "float registers for thread 0x%lx\n"),
155 (
unsigned long) current_thread);
165 warning (_(
"unknown register %d"), regno);
186 x86_thread_state_t gp_regs;
188 unsigned int gp_count = x86_THREAD_STATE_COUNT;
190 ret = thread_get_state
191 (current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
194 gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
195 gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);
200 gp_regs.uts.ts64.__fs &= 0xffff;
201 gp_regs.uts.ts64.__gs &= 0xffff;
203 ret = thread_set_state (current_thread, x86_THREAD_STATE,
204 (thread_state_t) &gp_regs,
205 x86_THREAD_STATE_COUNT);
211 x86_float_state_t fp_regs;
213 unsigned int fp_count = x86_FLOAT_STATE_COUNT;
215 ret = thread_get_state
216 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
219 gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
220 gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);
224 ret = thread_set_state (current_thread, x86_FLOAT_STATE,
225 (thread_state_t) & fp_regs,
226 x86_FLOAT_STATE_COUNT);
235 x86_thread_state32_t gp_regs;
237 unsigned int gp_count = x86_THREAD_STATE32_COUNT;
240 ret = thread_get_state
241 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs,
246 if (regno == -1 || regno == i)
250 ret = thread_set_state (current_thread, x86_THREAD_STATE32,
251 (thread_state_t) &gp_regs,
252 x86_THREAD_STATE32_COUNT);
259 x86_float_state32_t fp_regs;
260 unsigned int fp_count = x86_FLOAT_STATE32_COUNT;
263 ret = thread_get_state
264 (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs,
270 ret = thread_set_state (current_thread, x86_FLOAT_STATE32,
271 (thread_state_t) &fp_regs,
272 x86_FLOAT_STATE32_COUNT);
284 x86_debug_state_t dr_regs;
286 unsigned int dr_count;
292 dr_regs.dsh.flavor = x86_DEBUG_STATE;
293 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
294 dr_count = x86_DEBUG_STATE_COUNT;
295 ret = thread_get_state (current_thread, x86_DEBUG_STATE,
296 (thread_state_t) &dr_regs, &dr_count);
299 switch (dr_regs.dsh.flavor)
301 case x86_DEBUG_STATE32:
305 dr_regs.uds.ds32.__dr0 =
value;
308 dr_regs.uds.ds32.__dr1 =
value;
311 dr_regs.uds.ds32.__dr2 =
value;
314 dr_regs.uds.ds32.__dr3 =
value;
317 dr_regs.uds.ds32.__dr4 =
value;
320 dr_regs.uds.ds32.__dr5 =
value;
323 dr_regs.uds.ds32.__dr6 =
value;
326 dr_regs.uds.ds32.__dr7 =
value;
331 case x86_DEBUG_STATE64:
335 dr_regs.uds.ds64.__dr0 =
value;
338 dr_regs.uds.ds64.__dr1 =
value;
341 dr_regs.uds.ds64.__dr2 =
value;
344 dr_regs.uds.ds64.__dr3 =
value;
347 dr_regs.uds.ds64.__dr4 =
value;
350 dr_regs.uds.ds64.__dr5 =
value;
353 dr_regs.uds.ds64.__dr6 =
value;
356 dr_regs.uds.ds64.__dr7 =
value;
363 ret = thread_set_state (current_thread, dr_regs.dsh.flavor,
364 (thread_state_t) &dr_regs.uds, dr_count);
373 x86_debug_state_t dr_regs;
375 unsigned int dr_count;
381 dr_regs.dsh.flavor = x86_DEBUG_STATE;
382 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT;
383 dr_count = x86_DEBUG_STATE_COUNT;
384 ret = thread_get_state (current_thread, x86_DEBUG_STATE,
385 (thread_state_t) &dr_regs, &dr_count);
388 switch (dr_regs.dsh.flavor)
390 case x86_DEBUG_STATE32:
394 return dr_regs.uds.ds32.__dr0;
396 return dr_regs.uds.ds32.__dr1;
398 return dr_regs.uds.ds32.__dr2;
400 return dr_regs.uds.ds32.__dr3;
402 return dr_regs.uds.ds32.__dr4;
404 return dr_regs.uds.ds32.__dr5;
406 return dr_regs.uds.ds32.__dr6;
408 return dr_regs.uds.ds32.__dr7;
414 case x86_DEBUG_STATE64:
418 return dr_regs.uds.ds64.__dr0;
420 return dr_regs.uds.ds64.__dr1;
422 return dr_regs.uds.ds64.__dr2;
424 return dr_regs.uds.ds64.__dr3;
426 return dr_regs.uds.ds64.__dr4;
428 return dr_regs.uds.ds64.__dr5;
430 return dr_regs.uds.ds64.__dr6;
432 return dr_regs.uds.ds64.__dr7;
481 x86_thread_state_t gp_regs;
482 unsigned int gp_count = x86_THREAD_STATE_COUNT;
485 ret = thread_get_state (thread, x86_THREAD_STATE,
486 (thread_state_t) &gp_regs, &gp_count);
487 if (ret != KERN_SUCCESS)
497 if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
498 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
501 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
507#define X86_EFLAGS_T 0x100UL
520 static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 };
521 gdb_byte buf[
sizeof (darwin_syscall)];
525 && memcmp (buf, darwin_syscall,
sizeof (darwin_syscall)) == 0
526 && regs->uts.ts32.__eax == 0xb8 )
534 (regs->uts.ts32.__esp + 4, 4, byte_order);
536 (uctx_addr + 28, 4, byte_order);
538 flags_addr = mctx_addr + 12 + 9 * 4;
550amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
553 static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 };
554 gdb_byte buf[
sizeof (darwin_syscall)];
558 && memcmp (buf, darwin_syscall,
sizeof (darwin_syscall)) == 0
559 && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 )
566 (regs->uts.ts64.__rdi + 48, 8, byte_order);
567 flags_addr = mctx_addr + 16 + 17 * 8;
583 x86_thread_state_t regs;
584 unsigned int count = x86_THREAD_STATE_COUNT;
587 kret = thread_get_state (thread, x86_THREAD_STATE,
588 (thread_state_t) ®s, &count);
589 if (kret != KERN_SUCCESS)
591 warning (_(
"darwin_set_sstep: error %x, thread=%x\n"),
596 switch (regs.tsh.flavor)
598 case x86_THREAD_STATE32:
606 regs.uts.ts32.__eflags
607 = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) |
bit;
608 kret = thread_set_state (thread, x86_THREAD_STATE,
609 (thread_state_t) ®s, count);
614 case x86_THREAD_STATE64:
618 if (
enable && amd64_darwin_sstep_at_sigreturn (®s))
622 regs.uts.ts64.__rflags
623 = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) |
bit;
624 kret = thread_set_state (thread, x86_THREAD_STATE,
625 (thread_state_t) ®s, count);
631 error (_(
"darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor);
int amd64_darwin_thread_state_reg_offset[]
const int amd64_darwin_thread_state_num_regs
int amd64_native_gregset32_num_regs
void amd64_collect_native_gregset(const struct regcache *regcache, void *gregs, int regnum)
int * amd64_native_gregset32_reg_offset
int amd64_native_gregset64_num_regs
int * amd64_native_gregset64_reg_offset
void amd64_supply_native_gregset(struct regcache *regcache, const void *gregs, int regnum)
int amd64_native_gregset_supplies_p(struct gdbarch *gdbarch, int regnum)
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
int gdbarch_update_p(struct gdbarch_info info)
void gdbarch_info_fill(struct gdbarch_info *info)
struct gdbarch * target_gdbarch(void)
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
#define MACH_CHECK_ERROR(ret)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
static CORE_ADDR i386_darwin_dr_get_addr(int regnum)
static void i386_darwin_dr_set_control(unsigned long control)
static int i386_darwin_sstep_at_sigreturn(x86_thread_state_t *regs)
void _initialize_i386_darwin_nat()
static CORE_ADDR i386_darwin_dr_get(int regnum)
void darwin_set_sstep(thread_t thread, int enable)
static void i386_darwin_dr_set(int regnum, CORE_ADDR value)
static struct i386_darwin_nat_target darwin_target
static void i386_darwin_dr_set_addr(int regnum, CORE_ADDR addr)
static unsigned long i386_darwin_dr_get_control(void)
static unsigned long i386_darwin_dr_get_status(void)
void darwin_check_osabi(darwin_inferior *inf, thread_t thread)
const int i386_darwin_thread_state_num_regs
int i386_darwin_thread_state_reg_offset[]
#define I386_SSE_NUM_REGS
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
void add_inf_child_target(inf_child_target *target)
void store_registers(struct regcache *, int) override
void fetch_registers(struct regcache *, int) override
void(* set_addr)(int, CORE_ADDR)
unsigned long(* get_control)(void)
unsigned long(* get_status)(void)
void(* set_control)(unsigned long)
CORE_ADDR(* get_addr)(int)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
struct x86_dr_low_type x86_dr_low
void x86_set_debug_register_length(int len)