This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[RFA] Darwin: single step through sigreturn
- From: Tristan Gingold <gingold at adacore dot com>
- To: gdb-patches at sourceware dot org
- Date: Thu, 4 Dec 2008 16:28:25 +0100
- Subject: [RFA] Darwin: single step through sigreturn
Hi,
as other platform, single stepping through the sigreturn syscall is
special: changing the cpu state
is useless as the context is restored. The trace bit must be set in
the to be restored context.
Tristan.
2008-12-04 Tristan Gingold <gingold@adacore.com>
* i386-darwin-nat.c (i386_darwin_sstep_at_sigreturn): New function.
(amd64_darwin_sstep_at_sigreturn): New function.
(darwin_set_sstep): The sigreturn is a special case: the trace flag
must be set in the mcontext structure.
diff -c -p -r1.1 i386-darwin-nat.c
*** i386-darwin-nat.c 27 Nov 2008 09:23:01 -0000 1.1
--- i386-darwin-nat.c 4 Dec 2008 15:27:37 -0000
***************
*** 34,39 ****
--- 34,40 ----
#include "i387-tdep.h"
#include "gdbarch.h"
#include "arch-utils.h"
+ #include "gdbcore.h"
#include "darwin-nat.h"
#include "i386-darwin-tdep.h"
*************** darwin_check_osabi (darwin_inferior *inf
*** 433,438 ****
--- 434,503 ----
#define X86_EFLAGS_T 0x100UL
+ /* Returning from a signal trampoline is done by calling a
+ special system call (sigreturn). This system call
+ restores the registers that were saved when the signal was
+ raised, including %eflags/%rflags. That means that single-stepping
+ won't work. Instead, we'll have to modify the signal context
+ that's about to be restored, and set the trace flag there. */
+
+ static int
+ i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
+ {
+ static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int
0x80 */
+ gdb_byte buf[sizeof (darwin_syscall)];
+
+ /* Check if PC is at a sigreturn system call. */
+ if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf))
== 0
+ && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
+ && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)
+ {
+ ULONGEST uctx_addr;
+ ULONGEST mctx_addr;
+ ULONGEST flags_addr;
+ unsigned int eflags;
+
+ uctx_addr = read_memory_unsigned_integer (regs->uts.ts32.__esp
+ 4, 4);
+ mctx_addr = read_memory_unsigned_integer (uctx_addr + 28, 4);
+
+ flags_addr = mctx_addr + 12 + 9 * 4;
+ read_memory (flags_addr, (gdb_byte *) &eflags, 4);
+ eflags |= X86_EFLAGS_T;
+ write_memory (flags_addr, (gdb_byte *) &eflags, 4);
+
+ return 1;
+ }
+ return 0;
+ }
+
+ static int
+ amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
+ {
+ static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /*
syscall */
+ gdb_byte buf[sizeof (darwin_syscall)];
+
+ /* Check if PC is at a sigreturn system call. */
+ if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf))
== 0
+ && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0
+ && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /*
SYS_sigreturn */)
+ {
+ ULONGEST mctx_addr;
+ ULONGEST flags_addr;
+ unsigned int rflags;
+
+ mctx_addr = read_memory_unsigned_integer (regs->uts.ts64.__rdi
+ 48, 8);
+ flags_addr = mctx_addr + 16 + 17 * 8;
+
+ /* AMD64 is little endian. */
+ read_memory (flags_addr, (gdb_byte *) &rflags, 4);
+ rflags |= X86_EFLAGS_T;
+ write_memory (flags_addr, (gdb_byte *) &rflags, 4);
+
+ return 1;
+ }
+ return 0;
+ }
+
void
darwin_set_sstep (thread_t thread, int enable)
{
*************** darwin_set_sstep (thread_t thread, int e
*** 448,459 ****
--- 513,527 ----
kret, thread);
return;
}
+
switch (regs.tsh.flavor)
{
case x86_THREAD_STATE32:
{
__uint32_t bit = enable ? X86_EFLAGS_T : 0;
+ if (enable && i386_darwin_sstep_at_sigreturn (®s))
+ return;
if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts32.__eflags = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T)
| bit;
*************** darwin_set_sstep (thread_t thread, int e
*** 466,471 ****
--- 534,541 ----
{
__uint64_t bit = enable ? X86_EFLAGS_T : 0;
+ if (enable && amd64_darwin_sstep_at_sigreturn (®s))
+ return;
if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts64.__rflags = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T)
| bit;