OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
e0e0e543d5
binutils-gdb/gdb/i386-darwin-nat.c
Joel Brobecker 4c38e0a4fc Update copyright year in most headers. 
Automatic update by copyright.sh.
2010-01-01 07:32:07 +00:00

585 lines
16 KiB
C
Raw Blame History

/* Darwin support for GDB, the GNU debugger.
Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008, 2009, 2010
Free Software Foundation, Inc.
Contributed by Apple Computer, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "symfile.h"
#include "symtab.h"
#include "objfiles.h"
#include "gdbcmd.h"
#include "regcache.h"
#include "gdb_assert.h"
#include "i386-tdep.h"
#include "i387-tdep.h"
#include "gdbarch.h"
#include "arch-utils.h"
#include "gdbcore.h"
#include "darwin-nat.h"
#include "i386-darwin-tdep.h"
#ifdef BFD64
#include "amd64-nat.h"
#include "amd64-tdep.h"
#include "amd64-darwin-tdep.h"
#endif
/* Read register values from the inferior process.
If REGNO is -1, do this for all registers.
Otherwise, REGNO specifies which register (so we can save time). */
static void
i386_darwin_fetch_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
thread_t current_thread = ptid_get_tid (inferior_ptid);
int fetched = 0;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
#ifdef BFD64
if (gdbarch_ptr_bit (gdbarch) == 64)
{
if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_thread_state_t gp_regs;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for GP registers for thread 0x%ulx"), current_thread);
MACH_CHECK_ERROR (ret);
}
amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
fetched++;
}
if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_float_state_t fp_regs;
unsigned int fp_count = x86_FLOAT_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for float registers for thread 0x%ulx"), current_thread);
MACH_CHECK_ERROR (ret);
}
amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw);
fetched++;
}
}
else
#endif
{
if (regno == -1 || regno < I386_NUM_GREGS)
{
i386_thread_state_t gp_regs;
unsigned int gp_count = i386_THREAD_STATE_COUNT;
kern_return_t ret;
int i;
ret = thread_get_state
(current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for GP registers for thread 0x%ulx"), current_thread);
MACH_CHECK_ERROR (ret);
}
for (i = 0; i < I386_NUM_GREGS; i++)
regcache_raw_supply
(regcache, i,
(char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
fetched++;
}
if (regno == -1
|| (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
{
i386_float_state_t fp_regs;
unsigned int fp_count = i386_FLOAT_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for float registers for thread 0x%ulx"), current_thread);
MACH_CHECK_ERROR (ret);
}
i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
fetched++;
}
}
if (! fetched)
{
warning (_("unknown register %d"), regno);
regcache_raw_supply (regcache, regno, NULL);
}
}
/* Store our register values back into the inferior.
If REGNO is -1, do this for all registers.
Otherwise, REGNO specifies which register (so we can save time). */
static void
i386_darwin_store_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
thread_t current_thread = ptid_get_tid (inferior_ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
#ifdef BFD64
if (gdbarch_ptr_bit (gdbarch) == 64)
{
if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_thread_state_t gp_regs;
kern_return_t ret;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
ret = thread_get_state
(current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
&gp_count);
MACH_CHECK_ERROR (ret);
gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);
amd64_collect_native_gregset (regcache, &gp_regs.uts, regno);
ret = thread_set_state (current_thread, x86_THREAD_STATE,
(thread_state_t) &gp_regs,
x86_THREAD_STATE_COUNT);
MACH_CHECK_ERROR (ret);
}
if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_float_state_t fp_regs;
kern_return_t ret;
unsigned int fp_count = x86_FLOAT_STATE_COUNT;
ret = thread_get_state
(current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
MACH_CHECK_ERROR (ret);
gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);
amd64_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw);
ret = thread_set_state (current_thread, x86_FLOAT_STATE,
(thread_state_t) & fp_regs,
x86_FLOAT_STATE_COUNT);
MACH_CHECK_ERROR (ret);
}
}
else
#endif
{
if (regno == -1 || regno < I386_NUM_GREGS)
{
i386_thread_state_t gp_regs;
kern_return_t ret;
unsigned int gp_count = i386_THREAD_STATE_COUNT;
int i;
ret = thread_get_state
(current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
MACH_CHECK_ERROR (ret);
for (i = 0; i < I386_NUM_GREGS; i++)
if (regno == -1 || regno == i)
regcache_raw_collect
(regcache, i,
(char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
ret = thread_set_state (current_thread, i386_THREAD_STATE,
(thread_state_t) & gp_regs,
i386_THREAD_STATE_COUNT);
MACH_CHECK_ERROR (ret);
}
if (regno == -1
|| (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
{
i386_float_state_t fp_regs;
unsigned int fp_count = i386_FLOAT_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
MACH_CHECK_ERROR (ret);
i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);
ret = thread_set_state (current_thread, i386_FLOAT_STATE,
(thread_state_t) & fp_regs,
i386_FLOAT_STATE_COUNT);
MACH_CHECK_ERROR (ret);
}
}
}
/* Support for debug registers, boosted mostly from i386-linux-nat.c. */
#ifndef DR_FIRSTADDR
#define DR_FIRSTADDR 0
#endif
#ifndef DR_LASTADDR
#define DR_LASTADDR 3
#endif
#ifndef DR_STATUS
#define DR_STATUS 6
#endif
#ifndef DR_CONTROL
#define DR_CONTROL 7
#endif
static void
i386_darwin_dr_set (int regnum, uint32_t value)
{
int current_pid;
thread_t current_thread;
x86_debug_state_t dr_regs;
kern_return_t ret;
unsigned int dr_count = x86_DEBUG_STATE_COUNT;
gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
current_thread = ptid_get_tid (inferior_ptid);
dr_regs.dsh.flavor = x86_DEBUG_STATE32;
dr_regs.dsh.count = x86_DEBUG_STATE32_COUNT;
dr_count = x86_DEBUG_STATE_COUNT;
ret = thread_get_state (current_thread, x86_DEBUG_STATE,
(thread_state_t) &dr_regs, &dr_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error reading debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
MACH_CHECK_ERROR (ret);
}
switch (regnum)
{
case 0:
dr_regs.uds.ds32.__dr0 = value;
break;
case 1:
dr_regs.uds.ds32.__dr1 = value;
break;
case 2:
dr_regs.uds.ds32.__dr2 = value;
break;
case 3:
dr_regs.uds.ds32.__dr3 = value;
break;
case 4:
dr_regs.uds.ds32.__dr4 = value;
break;
case 5:
dr_regs.uds.ds32.__dr5 = value;
break;
case 6:
dr_regs.uds.ds32.__dr6 = value;
break;
case 7:
dr_regs.uds.ds32.__dr7 = value;
break;
}
ret = thread_set_state (current_thread, x86_DEBUG_STATE,
(thread_state_t) &dr_regs, dr_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error writing debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
MACH_CHECK_ERROR (ret);
}
}
static uint32_t
i386_darwin_dr_get (int regnum)
{
thread_t current_thread;
x86_debug_state_t dr_regs;
kern_return_t ret;
unsigned int dr_count = x86_DEBUG_STATE_COUNT;
gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
current_thread = ptid_get_tid (inferior_ptid);
dr_regs.dsh.flavor = x86_DEBUG_STATE32;
dr_regs.dsh.count = x86_DEBUG_STATE32_COUNT;
dr_count = x86_DEBUG_STATE_COUNT;
ret = thread_get_state (current_thread, x86_DEBUG_STATE,
(thread_state_t) &dr_regs, &dr_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error reading debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
MACH_CHECK_ERROR (ret);
}
switch (regnum)
{
case 0:
return dr_regs.uds.ds32.__dr0;
case 1:
return dr_regs.uds.ds32.__dr1;
case 2:
return dr_regs.uds.ds32.__dr2;
case 3:
return dr_regs.uds.ds32.__dr3;
case 4:
return dr_regs.uds.ds32.__dr4;
case 5:
return dr_regs.uds.ds32.__dr5;
case 6:
return dr_regs.uds.ds32.__dr6;
case 7:
return dr_regs.uds.ds32.__dr7;
default:
return -1;
}
}
void
i386_darwin_dr_set_control (unsigned long control)
{
i386_darwin_dr_set (DR_CONTROL, control);
}
void
i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
{
gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
}
void
i386_darwin_dr_reset_addr (int regnum)
{
gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
i386_darwin_dr_set (DR_FIRSTADDR + regnum, 0L);
}
unsigned long
i386_darwin_dr_get_status (void)
{
return i386_darwin_dr_get (DR_STATUS);
}
void
darwin_check_osabi (darwin_inferior *inf, thread_t thread)
{
if (gdbarch_osabi (target_gdbarch) == GDB_OSABI_UNKNOWN)
{
/* Attaching to a process. Let's figure out what kind it is. */
x86_thread_state_t gp_regs;
struct gdbarch_info info;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state (thread, x86_THREAD_STATE,
(thread_state_t) &gp_regs, &gp_count);
if (ret != KERN_SUCCESS)
{
MACH_CHECK_ERROR (ret);
return;
}
gdbarch_info_init (&info);
gdbarch_info_fill (&info);
info.byte_order = gdbarch_byte_order (target_gdbarch);
info.osabi = GDB_OSABI_DARWIN;
if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_x86_64);
else
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_i386_i386);
gdbarch_update_p (info);
}
}
#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)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
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, byte_order);
mctx_addr = read_memory_unsigned_integer
(uctx_addr + 28, 4, byte_order);
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;
}
#ifdef BFD64
static int
amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
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, byte_order);
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;
}
#endif
void
darwin_set_sstep (thread_t thread, int enable)
{
x86_thread_state_t regs;
unsigned int count = x86_THREAD_STATE_COUNT;
kern_return_t kret;
kret = thread_get_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, &count);
if (kret != KERN_SUCCESS)
{
printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
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 (&regs))
return;
if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts32.__eflags = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit;
kret = thread_set_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, count);
MACH_CHECK_ERROR (kret);
}
break;
#ifdef BFD64
case x86_THREAD_STATE64:
{
__uint64_t bit = enable ? X86_EFLAGS_T : 0;
if (enable && amd64_darwin_sstep_at_sigreturn (&regs))
return;
if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
return;
regs.uts.ts64.__rflags = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit;
kret = thread_set_state (thread, x86_THREAD_STATE,
(thread_state_t) &regs, count);
MACH_CHECK_ERROR (kret);
}
break;
#endif
default:
error (_("darwin_set_sstep: unknown flavour: %d\n"), regs.tsh.flavor);
}
}
void
darwin_complete_target (struct target_ops *target)
{
#ifdef BFD64
amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
#endif
target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
target->to_store_registers = i386_darwin_store_inferior_registers;
}
Reference in New Issue View Git Blame Copy Permalink