1 /* Darwin support for GDB, the GNU debugger.
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "gdb_assert.h"
32 #include "i386-tdep.h"
33 #include "i387-tdep.h"
35 #include "arch-utils.h"
38 #include "darwin-nat.h"
39 #include "i386-darwin-tdep.h"
42 #include "amd64-nat.h"
43 #include "amd64-tdep.h"
44 #include "amd64-darwin-tdep.h"
47 /* Read register values from the inferior process.
48 If REGNO is -1, do this for all registers.
49 Otherwise, REGNO specifies which register (so we can save time). */
51 i386_darwin_fetch_inferior_registers (struct target_ops
*ops
,
52 struct regcache
*regcache
, int regno
)
54 thread_t current_thread
= ptid_get_tid (inferior_ptid
);
56 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
59 if (gdbarch_ptr_bit (gdbarch
) == 64)
61 if (regno
== -1 || amd64_native_gregset_supplies_p (gdbarch
, regno
))
63 x86_thread_state_t gp_regs
;
64 unsigned int gp_count
= x86_THREAD_STATE_COUNT
;
67 ret
= thread_get_state
68 (current_thread
, x86_THREAD_STATE
, (thread_state_t
) & gp_regs
,
70 if (ret
!= KERN_SUCCESS
)
72 printf_unfiltered (_("Error calling thread_get_state for "
73 "GP registers for thread 0x%ulx"),
75 MACH_CHECK_ERROR (ret
);
77 amd64_supply_native_gregset (regcache
, &gp_regs
.uts
, -1);
81 if (regno
== -1 || !amd64_native_gregset_supplies_p (gdbarch
, regno
))
83 x86_float_state_t fp_regs
;
84 unsigned int fp_count
= x86_FLOAT_STATE_COUNT
;
87 ret
= thread_get_state
88 (current_thread
, x86_FLOAT_STATE
, (thread_state_t
) & fp_regs
,
90 if (ret
!= KERN_SUCCESS
)
92 printf_unfiltered (_("Error calling thread_get_state for "
93 "float registers for thread 0x%ulx"),
95 MACH_CHECK_ERROR (ret
);
97 amd64_supply_fxsave (regcache
, -1, &fp_regs
.ufs
.fs64
.__fpu_fcw
);
104 if (regno
== -1 || regno
< I386_NUM_GREGS
)
106 i386_thread_state_t gp_regs
;
107 unsigned int gp_count
= i386_THREAD_STATE_COUNT
;
111 ret
= thread_get_state
112 (current_thread
, i386_THREAD_STATE
, (thread_state_t
) & gp_regs
,
114 if (ret
!= KERN_SUCCESS
)
116 printf_unfiltered (_("Error calling thread_get_state for "
117 "GP registers for thread 0x%ulx"),
119 MACH_CHECK_ERROR (ret
);
121 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
124 (char *)&gp_regs
+ i386_darwin_thread_state_reg_offset
[i
]);
130 || (regno
>= I386_ST0_REGNUM
&& regno
< I386_SSE_NUM_REGS
))
132 i386_float_state_t fp_regs
;
133 unsigned int fp_count
= i386_FLOAT_STATE_COUNT
;
136 ret
= thread_get_state
137 (current_thread
, i386_FLOAT_STATE
, (thread_state_t
) & fp_regs
,
139 if (ret
!= KERN_SUCCESS
)
141 printf_unfiltered (_("Error calling thread_get_state for "
142 "float registers for thread 0x%ulx"),
144 MACH_CHECK_ERROR (ret
);
146 i387_supply_fxsave (regcache
, -1, &fp_regs
.__fpu_fcw
);
153 warning (_("unknown register %d"), regno
);
154 regcache_raw_supply (regcache
, regno
, NULL
);
158 /* Store our register values back into the inferior.
159 If REGNO is -1, do this for all registers.
160 Otherwise, REGNO specifies which register (so we can save time). */
163 i386_darwin_store_inferior_registers (struct target_ops
*ops
,
164 struct regcache
*regcache
, int regno
)
166 thread_t current_thread
= ptid_get_tid (inferior_ptid
);
167 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
170 if (gdbarch_ptr_bit (gdbarch
) == 64)
172 if (regno
== -1 || amd64_native_gregset_supplies_p (gdbarch
, regno
))
174 x86_thread_state_t gp_regs
;
176 unsigned int gp_count
= x86_THREAD_STATE_COUNT
;
178 ret
= thread_get_state
179 (current_thread
, x86_THREAD_STATE
, (thread_state_t
) &gp_regs
,
181 MACH_CHECK_ERROR (ret
);
182 gdb_assert (gp_regs
.tsh
.flavor
== x86_THREAD_STATE64
);
183 gdb_assert (gp_regs
.tsh
.count
== x86_THREAD_STATE64_COUNT
);
185 amd64_collect_native_gregset (regcache
, &gp_regs
.uts
, regno
);
187 ret
= thread_set_state (current_thread
, x86_THREAD_STATE
,
188 (thread_state_t
) &gp_regs
,
189 x86_THREAD_STATE_COUNT
);
190 MACH_CHECK_ERROR (ret
);
193 if (regno
== -1 || !amd64_native_gregset_supplies_p (gdbarch
, regno
))
195 x86_float_state_t fp_regs
;
197 unsigned int fp_count
= x86_FLOAT_STATE_COUNT
;
199 ret
= thread_get_state
200 (current_thread
, x86_FLOAT_STATE
, (thread_state_t
) & fp_regs
,
202 MACH_CHECK_ERROR (ret
);
203 gdb_assert (fp_regs
.fsh
.flavor
== x86_FLOAT_STATE64
);
204 gdb_assert (fp_regs
.fsh
.count
== x86_FLOAT_STATE64_COUNT
);
206 amd64_collect_fxsave (regcache
, regno
, &fp_regs
.ufs
.fs64
.__fpu_fcw
);
208 ret
= thread_set_state (current_thread
, x86_FLOAT_STATE
,
209 (thread_state_t
) & fp_regs
,
210 x86_FLOAT_STATE_COUNT
);
211 MACH_CHECK_ERROR (ret
);
217 if (regno
== -1 || regno
< I386_NUM_GREGS
)
219 i386_thread_state_t gp_regs
;
221 unsigned int gp_count
= i386_THREAD_STATE_COUNT
;
224 ret
= thread_get_state
225 (current_thread
, i386_THREAD_STATE
, (thread_state_t
) & gp_regs
,
227 MACH_CHECK_ERROR (ret
);
229 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
230 if (regno
== -1 || regno
== i
)
233 (char *)&gp_regs
+ i386_darwin_thread_state_reg_offset
[i
]);
235 ret
= thread_set_state (current_thread
, i386_THREAD_STATE
,
236 (thread_state_t
) & gp_regs
,
237 i386_THREAD_STATE_COUNT
);
238 MACH_CHECK_ERROR (ret
);
242 || (regno
>= I386_ST0_REGNUM
&& regno
< I386_SSE_NUM_REGS
))
244 i386_float_state_t fp_regs
;
245 unsigned int fp_count
= i386_FLOAT_STATE_COUNT
;
248 ret
= thread_get_state
249 (current_thread
, i386_FLOAT_STATE
, (thread_state_t
) & fp_regs
,
251 MACH_CHECK_ERROR (ret
);
253 i387_collect_fxsave (regcache
, regno
, &fp_regs
.__fpu_fcw
);
255 ret
= thread_set_state (current_thread
, i386_FLOAT_STATE
,
256 (thread_state_t
) & fp_regs
,
257 i386_FLOAT_STATE_COUNT
);
258 MACH_CHECK_ERROR (ret
);
264 /* Support for debug registers, boosted mostly from i386-linux-nat.c. */
267 #define DR_FIRSTADDR 0
271 #define DR_LASTADDR 3
284 i386_darwin_dr_set (int regnum
, uint32_t value
)
287 thread_t current_thread
;
288 x86_debug_state_t dr_regs
;
290 unsigned int dr_count
= x86_DEBUG_STATE_COUNT
;
292 gdb_assert (regnum
>= 0 && regnum
<= DR_CONTROL
);
294 current_thread
= ptid_get_tid (inferior_ptid
);
296 dr_regs
.dsh
.flavor
= x86_DEBUG_STATE32
;
297 dr_regs
.dsh
.count
= x86_DEBUG_STATE32_COUNT
;
298 dr_count
= x86_DEBUG_STATE_COUNT
;
299 ret
= thread_get_state (current_thread
, x86_DEBUG_STATE
,
300 (thread_state_t
) &dr_regs
, &dr_count
);
302 if (ret
!= KERN_SUCCESS
)
304 printf_unfiltered (_("Error reading debug registers "
305 "thread 0x%x via thread_get_state\n"),
306 (int) current_thread
);
307 MACH_CHECK_ERROR (ret
);
313 dr_regs
.uds
.ds32
.__dr0
= value
;
316 dr_regs
.uds
.ds32
.__dr1
= value
;
319 dr_regs
.uds
.ds32
.__dr2
= value
;
322 dr_regs
.uds
.ds32
.__dr3
= value
;
325 dr_regs
.uds
.ds32
.__dr4
= value
;
328 dr_regs
.uds
.ds32
.__dr5
= value
;
331 dr_regs
.uds
.ds32
.__dr6
= value
;
334 dr_regs
.uds
.ds32
.__dr7
= value
;
338 ret
= thread_set_state (current_thread
, x86_DEBUG_STATE
,
339 (thread_state_t
) &dr_regs
, dr_count
);
341 if (ret
!= KERN_SUCCESS
)
343 printf_unfiltered (_("Error writing debug registers "
344 "thread 0x%x via thread_get_state\n"),
345 (int) current_thread
);
346 MACH_CHECK_ERROR (ret
);
351 i386_darwin_dr_get (int regnum
)
353 thread_t current_thread
;
354 x86_debug_state_t dr_regs
;
356 unsigned int dr_count
= x86_DEBUG_STATE_COUNT
;
358 gdb_assert (regnum
>= 0 && regnum
<= DR_CONTROL
);
360 current_thread
= ptid_get_tid (inferior_ptid
);
362 dr_regs
.dsh
.flavor
= x86_DEBUG_STATE32
;
363 dr_regs
.dsh
.count
= x86_DEBUG_STATE32_COUNT
;
364 dr_count
= x86_DEBUG_STATE_COUNT
;
365 ret
= thread_get_state (current_thread
, x86_DEBUG_STATE
,
366 (thread_state_t
) &dr_regs
, &dr_count
);
368 if (ret
!= KERN_SUCCESS
)
370 printf_unfiltered (_("Error reading debug registers "
371 "thread 0x%x via thread_get_state\n"),
372 (int) current_thread
);
373 MACH_CHECK_ERROR (ret
);
379 return dr_regs
.uds
.ds32
.__dr0
;
381 return dr_regs
.uds
.ds32
.__dr1
;
383 return dr_regs
.uds
.ds32
.__dr2
;
385 return dr_regs
.uds
.ds32
.__dr3
;
387 return dr_regs
.uds
.ds32
.__dr4
;
389 return dr_regs
.uds
.ds32
.__dr5
;
391 return dr_regs
.uds
.ds32
.__dr6
;
393 return dr_regs
.uds
.ds32
.__dr7
;
400 i386_darwin_dr_set_control (unsigned long control
)
402 i386_darwin_dr_set (DR_CONTROL
, control
);
406 i386_darwin_dr_set_addr (int regnum
, CORE_ADDR addr
)
408 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
410 i386_darwin_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
414 i386_darwin_dr_reset_addr (int regnum
)
416 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
418 i386_darwin_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
422 i386_darwin_dr_get_status (void)
424 return i386_darwin_dr_get (DR_STATUS
);
428 darwin_check_osabi (darwin_inferior
*inf
, thread_t thread
)
430 if (gdbarch_osabi (target_gdbarch
) == GDB_OSABI_UNKNOWN
)
432 /* Attaching to a process. Let's figure out what kind it is. */
433 x86_thread_state_t gp_regs
;
434 struct gdbarch_info info
;
435 unsigned int gp_count
= x86_THREAD_STATE_COUNT
;
438 ret
= thread_get_state (thread
, x86_THREAD_STATE
,
439 (thread_state_t
) &gp_regs
, &gp_count
);
440 if (ret
!= KERN_SUCCESS
)
442 MACH_CHECK_ERROR (ret
);
446 gdbarch_info_init (&info
);
447 gdbarch_info_fill (&info
);
448 info
.byte_order
= gdbarch_byte_order (target_gdbarch
);
449 info
.osabi
= GDB_OSABI_DARWIN
;
450 if (gp_regs
.tsh
.flavor
== x86_THREAD_STATE64
)
451 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_i386
,
454 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_i386
,
456 gdbarch_update_p (info
);
460 #define X86_EFLAGS_T 0x100UL
462 /* Returning from a signal trampoline is done by calling a
463 special system call (sigreturn). This system call
464 restores the registers that were saved when the signal was
465 raised, including %eflags/%rflags. That means that single-stepping
466 won't work. Instead, we'll have to modify the signal context
467 that's about to be restored, and set the trace flag there. */
470 i386_darwin_sstep_at_sigreturn (x86_thread_state_t
*regs
)
472 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
473 static const gdb_byte darwin_syscall
[] = { 0xcd, 0x80 }; /* int 0x80 */
474 gdb_byte buf
[sizeof (darwin_syscall
)];
476 /* Check if PC is at a sigreturn system call. */
477 if (target_read_memory (regs
->uts
.ts32
.__eip
, buf
, sizeof (buf
)) == 0
478 && memcmp (buf
, darwin_syscall
, sizeof (darwin_syscall
)) == 0
479 && regs
->uts
.ts32
.__eax
== 0xb8 /* SYS_sigreturn */)
486 uctx_addr
= read_memory_unsigned_integer
487 (regs
->uts
.ts32
.__esp
+ 4, 4, byte_order
);
488 mctx_addr
= read_memory_unsigned_integer
489 (uctx_addr
+ 28, 4, byte_order
);
491 flags_addr
= mctx_addr
+ 12 + 9 * 4;
492 read_memory (flags_addr
, (gdb_byte
*) &eflags
, 4);
493 eflags
|= X86_EFLAGS_T
;
494 write_memory (flags_addr
, (gdb_byte
*) &eflags
, 4);
503 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t
*regs
)
505 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
506 static const gdb_byte darwin_syscall
[] = { 0x0f, 0x05 }; /* syscall */
507 gdb_byte buf
[sizeof (darwin_syscall
)];
509 /* Check if PC is at a sigreturn system call. */
510 if (target_read_memory (regs
->uts
.ts64
.__rip
, buf
, sizeof (buf
)) == 0
511 && memcmp (buf
, darwin_syscall
, sizeof (darwin_syscall
)) == 0
512 && (regs
->uts
.ts64
.__rax
& 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)
518 mctx_addr
= read_memory_unsigned_integer
519 (regs
->uts
.ts64
.__rdi
+ 48, 8, byte_order
);
520 flags_addr
= mctx_addr
+ 16 + 17 * 8;
522 /* AMD64 is little endian. */
523 read_memory (flags_addr
, (gdb_byte
*) &rflags
, 4);
524 rflags
|= X86_EFLAGS_T
;
525 write_memory (flags_addr
, (gdb_byte
*) &rflags
, 4);
534 darwin_set_sstep (thread_t thread
, int enable
)
536 x86_thread_state_t regs
;
537 unsigned int count
= x86_THREAD_STATE_COUNT
;
540 kret
= thread_get_state (thread
, x86_THREAD_STATE
,
541 (thread_state_t
) ®s
, &count
);
542 if (kret
!= KERN_SUCCESS
)
544 printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
549 switch (regs
.tsh
.flavor
)
551 case x86_THREAD_STATE32
:
553 __uint32_t bit
= enable
? X86_EFLAGS_T
: 0;
555 if (enable
&& i386_darwin_sstep_at_sigreturn (®s
))
557 if ((regs
.uts
.ts32
.__eflags
& X86_EFLAGS_T
) == bit
)
559 regs
.uts
.ts32
.__eflags
560 = (regs
.uts
.ts32
.__eflags
& ~X86_EFLAGS_T
) | bit
;
561 kret
= thread_set_state (thread
, x86_THREAD_STATE
,
562 (thread_state_t
) ®s
, count
);
563 MACH_CHECK_ERROR (kret
);
567 case x86_THREAD_STATE64
:
569 __uint64_t bit
= enable
? X86_EFLAGS_T
: 0;
571 if (enable
&& amd64_darwin_sstep_at_sigreturn (®s
))
573 if ((regs
.uts
.ts64
.__rflags
& X86_EFLAGS_T
) == bit
)
575 regs
.uts
.ts64
.__rflags
576 = (regs
.uts
.ts64
.__rflags
& ~X86_EFLAGS_T
) | bit
;
577 kret
= thread_set_state (thread
, x86_THREAD_STATE
,
578 (thread_state_t
) ®s
, count
);
579 MACH_CHECK_ERROR (kret
);
584 error (_("darwin_set_sstep: unknown flavour: %d"), regs
.tsh
.flavor
);
589 darwin_complete_target (struct target_ops
*target
)
592 amd64_native_gregset64_reg_offset
= amd64_darwin_thread_state_reg_offset
;
593 amd64_native_gregset64_num_regs
= amd64_darwin_thread_state_num_regs
;
594 amd64_native_gregset32_reg_offset
= i386_darwin_thread_state_reg_offset
;
595 amd64_native_gregset32_num_regs
= i386_darwin_thread_state_num_regs
;
598 target
->to_fetch_registers
= i386_darwin_fetch_inferior_registers
;
599 target
->to_store_registers
= i386_darwin_store_inferior_registers
;