* [RFA] Darwin/x86 port (v4 - part 3/4: i386-darwin files)
@ 2008-11-14 18:43 Tristan Gingold
2008-11-19 1:47 ` Stan Shebs
0 siblings, 1 reply; 3+ messages in thread
From: Tristan Gingold @ 2008-11-14 18:43 UTC (permalink / raw)
To: gdb-patches
i386-darwin-tdep.h:
/* Target-dependent code for Darwin x86.
Copyright (C) 2008 Free Software Foundation, 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/
>. */
#ifndef __I386_DARWIN_TDEP_H__
#define __I386_DARWIN_TDEP_H__
#include <mach/thread_status.h>
#define IS_GP_REGNUM(regno) ((regno >= FIRST_GP_REGNUM) && (regno <=
LAST_GP_REGNUM))
#define IS_FP_REGNUM(regno) ((regno >= FIRST_FP_REGNUM) && (regno <=
LAST_FP_REGNUM))
#define IS_VP_REGNUM(regno) ((regno >= FIRST_VP_REGNUM) && (regno <=
LAST_VP_REGNUM))
#define FIRST_GP_REGNUM 0
#define LAST_GP_REGNUM 15
#define NUM_GP_REGS ((LAST_GP_REGNUM + 1) - FIRST_GP_REGNUM)
#define FIRST_FP_REGNUM 16
#define LAST_FP_REGNUM 31
#define NUM_FP_REGS ((LAST_FP_REGNUM + 1) - FIRST_FP_REGNUM)
#define FIRST_VP_REGNUM 32
#define LAST_VP_REGNUM 40
#define NUM_VP_REGS ((LAST_VP_REGNUM + 1) - FIRST_VP_REGNUM)
#define IS_GP_REGNUM_64(regno) ((regno >= FIRST_GP_REGNUM_64) &&
(regno <= LAST_GP_REGNUM_64))
#define IS_FP_REGNUM_64(regno) ((regno >= FIRST_FP_REGNUM_64) &&
(regno <= LAST_FP_REGNUM_64))
#define IS_VP_REGNUM_64(regno) ((regno >= FIRST_VP_REGNUM_64) &&
(regno <= LAST_VP_REGNUM_64))
#define FIRST_GP_REGNUM_64 0
#define LAST_GP_REGNUM_64 23
#define NUM_GP_REGS_64 ((LAST_GP_REGNUM_64 + 1) - FIRST_GP_REGNUM_64)
#define FIRST_FP_REGNUM_64 24
#define LAST_FP_REGNUM_64 39
#define NUM_FP_REGS_64 ((LAST_FP_REGNUM_64 + 1) - FIRST_FP_REGNUM_64)
#define FIRST_VP_REGNUM_64 40
#define LAST_VP_REGNUM_64 55
#define NUM_VP_REGS_64 ((LAST_VP_REGNUM_64 + 1) - FIRST_VP_REGNUM_64)
void i386_darwin_fetch_gp_registers (struct regcache *regcache,
i386_thread_state_t *sp_regs);
void i386_darwin_store_gp_registers (struct regcache *regcache,
i386_thread_state_t *sp_regs);
void amd64_darwin_fetch_gp_registers (struct regcache *regcache,
x86_thread_state64_t *sp_regs);
void amd64_darwin_store_gp_registers (struct regcache *regcache,
x86_thread_state64_t *sp_regs);
void i386_darwin_fetch_fp_registers (struct regcache *regcache,
i386_float_state_t *fp_regs);
int i386_darwin_store_fp_registers (struct regcache *regcache,
i386_float_state_t *fp_regs);
void amd64_darwin_fetch_fp_registers (struct regcache *regcache,
x86_float_state64_t *fp_regs);
int amd64_darwin_store_fp_registers (struct regcache *regcache,
x86_float_state64_t *fp_regs);
#endif /* __I386_DARWIN_TDEP_H__ */
i386-darwin-tdep.c:
/* Darwin support for GDB, the GNU debugger.
Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2005, 2008
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 "gdbcore.h"
#include "target.h"
#include "floatformat.h"
#include "symtab.h"
#include "regcache.h"
#include "libbfd.h"
#include "objfiles.h"
#include "i387-tdep.h"
#include "i386-tdep.h"
#include "amd64-tdep.h"
#include "osabi.h"
#include "ui-out.h"
#include "symtab.h"
#include "frame.h"
#include "gdb_assert.h"
#include <mach/thread_status.h>
#include <sys/sysctl.h>
#include "i386-darwin-tdep.h"
#define supply_unsigned_int(regcache, regnum, val) \
store_unsigned_integer (buf, 4, val); \
regcache_raw_supply (regcache, regnum, buf);
#define collect_unsigned_int(regcache, regnum, addr) \
regcache_raw_collect (regcache, regnum, buf); \
(* (addr)) = extract_unsigned_integer (buf, 4);
#define supply_unsigned_int64(regcache, regnum, val) \
store_unsigned_integer (buf, 8, val); \
regcache_raw_supply (regcache, regnum, buf);
#define collect_unsigned_int64(regcache, regnum, addr) \
regcache_raw_collect (regcache, regnum, buf); \
(* (addr)) = extract_unsigned_integer (buf, 8);
void
i386_darwin_fetch_gp_registers (struct regcache *regcache,
i386_thread_state_t *sp_regs)
{
gdb_byte buf[4];
supply_unsigned_int (regcache, 0, sp_regs->__eax);
supply_unsigned_int (regcache, 1, sp_regs->__ecx);
supply_unsigned_int (regcache, 2, sp_regs->__edx);
supply_unsigned_int (regcache, 3, sp_regs->__ebx);
supply_unsigned_int (regcache, 4, sp_regs->__esp);
supply_unsigned_int (regcache, 5, sp_regs->__ebp);
supply_unsigned_int (regcache, 6, sp_regs->__esi);
supply_unsigned_int (regcache, 7, sp_regs->__edi);
supply_unsigned_int (regcache, 8, sp_regs->__eip);
supply_unsigned_int (regcache, 9, sp_regs->__eflags);
supply_unsigned_int (regcache, 10, sp_regs->__cs);
supply_unsigned_int (regcache, 11, sp_regs->__ss);
supply_unsigned_int (regcache, 12, sp_regs->__ds);
supply_unsigned_int (regcache, 13, sp_regs->__es);
supply_unsigned_int (regcache, 14, sp_regs->__fs);
supply_unsigned_int (regcache, 15, sp_regs->__gs);
}
void
i386_darwin_store_gp_registers (struct regcache *regcache,
i386_thread_state_t *sp_regs)
{
unsigned char buf[4];
collect_unsigned_int (regcache, 0, &sp_regs->__eax);
collect_unsigned_int (regcache, 1, &sp_regs->__ecx);
collect_unsigned_int (regcache, 2, &sp_regs->__edx);
collect_unsigned_int (regcache, 3, &sp_regs->__ebx);
collect_unsigned_int (regcache, 4, &sp_regs->__esp);
collect_unsigned_int (regcache, 5, &sp_regs->__ebp);
collect_unsigned_int (regcache, 6, &sp_regs->__esi);
collect_unsigned_int (regcache, 7, &sp_regs->__edi);
collect_unsigned_int (regcache, 8, &sp_regs->__eip);
collect_unsigned_int (regcache, 9, &sp_regs->__eflags);
collect_unsigned_int (regcache, 10, &sp_regs->__cs);
collect_unsigned_int (regcache, 11, &sp_regs->__ss);
collect_unsigned_int (regcache, 12, &sp_regs->__ds);
collect_unsigned_int (regcache, 13, &sp_regs->__es);
collect_unsigned_int (regcache, 14, &sp_regs->__fs);
collect_unsigned_int (regcache, 15, &sp_regs->__gs);
}
void
amd64_darwin_fetch_gp_registers (struct regcache *regcache,
x86_thread_state64_t *sp_regs)
{
unsigned char buf[8];
supply_unsigned_int64 (regcache, AMD64_RAX_REGNUM, sp_regs->__rax);
supply_unsigned_int64 (regcache, AMD64_RBX_REGNUM, sp_regs->__rbx);
supply_unsigned_int64 (regcache, AMD64_RCX_REGNUM, sp_regs->__rcx);
supply_unsigned_int64 (regcache, AMD64_RDX_REGNUM, sp_regs->__rdx);
supply_unsigned_int64 (regcache, AMD64_RDI_REGNUM, sp_regs->__rdi);
supply_unsigned_int64 (regcache, AMD64_RSI_REGNUM, sp_regs->__rsi);
supply_unsigned_int64 (regcache, AMD64_RBP_REGNUM, sp_regs->__rbp);
supply_unsigned_int64 (regcache, AMD64_RSP_REGNUM, sp_regs->__rsp);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM, sp_regs->__r8);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 1, sp_regs->__r9);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 2, sp_regs-
>__r10);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 3, sp_regs-
>__r11);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 4, sp_regs-
>__r12);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 5, sp_regs-
>__r13);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 6, sp_regs-
>__r14);
supply_unsigned_int64 (regcache, AMD64_R8_REGNUM + 7, sp_regs-
>__r15);
supply_unsigned_int64 (regcache, AMD64_RIP_REGNUM, sp_regs->__rip);
supply_unsigned_int64 (regcache, AMD64_EFLAGS_REGNUM, sp_regs-
>__rflags);
supply_unsigned_int64 (regcache, AMD64_CS_REGNUM, sp_regs->__cs);
supply_unsigned_int64 (regcache, AMD64_FS_REGNUM, sp_regs->__fs);
supply_unsigned_int64 (regcache, AMD64_GS_REGNUM, sp_regs->__gs);
}
void
amd64_darwin_store_gp_registers (struct regcache *regcache,
x86_thread_state64_t *sp_regs)
{
unsigned char buf[8];
collect_unsigned_int64 (regcache, AMD64_RAX_REGNUM, &sp_regs->__rax);
collect_unsigned_int64 (regcache, AMD64_RBX_REGNUM, &sp_regs->__rbx);
collect_unsigned_int64 (regcache, AMD64_RCX_REGNUM, &sp_regs->__rcx);
collect_unsigned_int64 (regcache, AMD64_RDX_REGNUM, &sp_regs->__rdx);
collect_unsigned_int64 (regcache, AMD64_RDI_REGNUM, &sp_regs->__rdi);
collect_unsigned_int64 (regcache, AMD64_RSI_REGNUM, &sp_regs->__rsi);
collect_unsigned_int64 (regcache, AMD64_RBP_REGNUM, &sp_regs->__rbp);
collect_unsigned_int64 (regcache, AMD64_RSP_REGNUM, &sp_regs->__rsp);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM, &sp_regs->__r8);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 1, &sp_regs-
>__r9);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 2, &sp_regs-
>__r10);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 3, &sp_regs-
>__r11);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 4, &sp_regs-
>__r12);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 5, &sp_regs-
>__r13);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 6, &sp_regs-
>__r14);
collect_unsigned_int64 (regcache, AMD64_R8_REGNUM + 7, &sp_regs-
>__r15);
collect_unsigned_int64 (regcache, AMD64_RIP_REGNUM, &sp_regs->__rip);
collect_unsigned_int64 (regcache, AMD64_EFLAGS_REGNUM, &sp_regs-
>__rflags);
collect_unsigned_int64 (regcache, AMD64_CS_REGNUM, &sp_regs->__cs);
collect_unsigned_int64 (regcache, AMD64_FS_REGNUM, &sp_regs->__fs);
collect_unsigned_int64 (regcache, AMD64_GS_REGNUM, &sp_regs->__gs);
}
/* Fetching the the registers from the inferior into our reg cache.
FP_REGS is a structure that mirrors the Mach structure
struct i386_float_state. The "fpu_fcw" field inside that
structure is the start of a block which is identical
to the FXSAVE/FXRSTOR instructions' format. */
void
i386_darwin_fetch_fp_registers (struct regcache *regcache,
i386_float_state_t *fp_regs)
{
i387_supply_fxsave (regcache, -1, &fp_regs->__fpu_fcw);
}
void
amd64_darwin_fetch_fp_registers (struct regcache *regcache,
x86_float_state64_t *fp_regs)
{
i387_supply_fxsave (regcache, -1, &fp_regs->__fpu_fcw);
}
/* Get the floating point registers from our local register cache
and stick them in FP_REGS in for sending to the inferior via a
syscall. If the local register cache has valid FP values, this
function returns 1. If the local register cache does not have
valid FP values -- and so FP_REGS should not be pushed into the
inferior -- this function returns 0. */
int
i386_darwin_store_fp_registers (struct regcache *regcache,
i386_float_state_t *fp_regs)
{
i387_collect_fxsave (regcache, -1, &fp_regs->__fpu_fcw);
return 1;
}
int
amd64_darwin_store_fp_registers (struct regcache *regcache,
x86_float_state64_t *fp_regs)
{
i387_collect_fxsave (regcache, -1, &fp_regs->__fpu_fcw);
return 1;
}
/* Offsets into the struct i386_thread_state where we'll find the
saved regs. */
/* From <mach/i386/thread_status.h> and i386-tdep.h */
static int i386_darwin_thread_state_reg_offset[] =
{
0 * 4, /* EAX */
2 * 4, /* ECX */
3 * 4, /* EDX */
1 * 4, /* EBX */
7 * 4, /* ESP */
6 * 4, /* EBP */
5 * 4, /* ESI */
4 * 4, /* EDI */
10 * 4, /* EIP */
9 * 4, /* EFLAGS */
11 * 4, /* CS */
8, /* SS */
12 * 4, /* DS */
13 * 4, /* ES */
14 * 4, /* FS */
15 * 4 /* GS */
};
/* Offsets into the struct x86_thread_state64 where we'll find the
saved regs. */
/* From <mach/i386/thread_status.h> and amd64-tdep.h */
static int amd64_darwin_thread_state_reg_offset[] =
{
0 * 8, /* %rax */
1 * 8, /* %rbx */
2 * 8, /* %rcx */
3 * 8, /* %rdx */
5 * 8, /* %rsi */
4 * 8, /* %rdi */
6 * 8, /* %rbp */
7 * 8, /* %rsp */
8 * 8, /* %r8 ... */
9 * 8,
10 * 8,
11 * 8,
12 * 8,
13 * 8,
14 * 8,
15 * 8, /* ... %r15 */
16 * 8, /* %rip */
17 * 8, /* %rflags */
18 * 8, /* %cs */
-1, /* %ss */
-1, /* %ds */
-1, /* %es */
19 * 8, /* %fs */
20 * 8 /* %gs */
};
static void
i386_darwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* We support the SSE registers. */
tdep->num_xmm_regs = I386_NUM_XREGS - 1;
set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS);
tdep->struct_return = reg_struct_return;
tdep->sigcontext_addr = NULL;
tdep->sc_reg_offset = i386_darwin_thread_state_reg_offset;
tdep->sc_num_regs = 16;
tdep->jb_pc_offset = 20;
}
static void
x86_darwin_init_abi_64 (struct gdbarch_info info, struct gdbarch
*gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
amd64_init_abi (info, gdbarch);
tdep->struct_return = reg_struct_return;
/* We don't do signals yet. */
tdep->sigcontext_addr = NULL;
tdep->sc_reg_offset = amd64_darwin_thread_state_reg_offset;
tdep->sc_num_regs = ARRAY_SIZE
(amd64_darwin_thread_state_reg_offset);
tdep->jb_pc_offset = 148;
}
static enum gdb_osabi
i386_mach_o_osabi_sniffer (bfd *abfd)
{
if (!bfd_check_format (abfd, bfd_object))
return GDB_OSABI_UNKNOWN;
if (bfd_get_arch (abfd) == bfd_arch_i386)
return GDB_OSABI_DARWIN;
return GDB_OSABI_UNKNOWN;
}
void
_initialize_i386_darwin_tdep (void)
{
gdbarch_register_osabi_sniffer (bfd_arch_unknown,
bfd_target_mach_o_flavour,
i386_mach_o_osabi_sniffer);
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_i386_i386,
GDB_OSABI_DARWIN, i386_darwin_init_abi);
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_DARWIN, x86_darwin_init_abi_64);
}
i386-darwin-nat.c:
/* Darwin support for GDB, the GNU debugger.
Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008
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 "i386-darwin-tdep.h"
#include "darwin-nat.h"
#include <mach/thread_act.h>
static void
i386_darwin_fetch_inferior_registers (struct regcache *regcache, int
regno);
static void
validate_inferior_registers (struct regcache *regcache, int regno)
{
int i;
if (regno == -1)
{
for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
{
if (!regcache_valid_p (regcache, i))
i386_darwin_fetch_inferior_registers (regcache, i);
}
}
else if (!regcache_valid_p (regcache, regno))
{
i386_darwin_fetch_inferior_registers (regcache, regno);
}
}
/* NOTE: the following code was just lifted from i386-tdep.c. Ultra-
cheesy,
but it's time to get this thing building for submission...
jmolenda/2004-05-17 */
static int
i386_sse_regnum_p (struct gdbarch *gdbarch, int regnum)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (I387_NUM_XMM_REGS (tdep) == 0)
return 0;
return I387_XMM0_REGNUM (tdep) <= regnum && regnum <
I387_MXCSR_REGNUM (tdep);
}
/* NOTE: the following code was just lifted from i386-tdep.c. Ultra-
cheesy,
but it's time to get this thing building for submission...
jmolenda/2004-05-17 */
static int
i386_mxcsr_regnum_p (struct gdbarch *gdbarch, int regnum)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (I387_NUM_XMM_REGS (tdep)== 0)
return 0;
return (regnum == I387_MXCSR_REGNUM (tdep));
}
/* 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 regcache *regcache, int
regno)
{
int current_pid;
thread_t current_thread;
int fetched = 0;
current_pid = ptid_get_pid (inferior_ptid);
current_thread = ptid_get_tid (inferior_ptid);
if (gdbarch_ptr_bit (current_gdbarch) == 64)
{
if ((regno == -1) || IS_GP_REGNUM_64 (regno))
{
x86_thread_state_t gp_regs;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t 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_darwin_fetch_gp_registers (regcache,
&gp_regs.uts.ts64);
fetched++;
}
if ((regno == -1)
|| IS_FP_REGNUM_64 (regno)
|| IS_VP_REGNUM_64 (regno))
{
x86_float_state_t fp_regs;
unsigned int fp_count = x86_FLOAT_STATE_COUNT;
kern_return_t 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_darwin_fetch_fp_registers (regcache,
&fp_regs.ufs.fs64);
fetched++;
}
}
else if (gdbarch_osabi (current_gdbarch) == GDB_OSABI_DARWIN)
{
if ((regno == -1) || IS_GP_REGNUM (regno))
{
i386_thread_state_t gp_regs;
unsigned int gp_count = i386_THREAD_STATE_COUNT;
kern_return_t 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);
}
i386_darwin_fetch_gp_registers (regcache, &gp_regs);
fetched++;
}
if ((regno == -1)
|| IS_FP_REGNUM (regno)
|| i386_sse_regnum_p (current_gdbarch, regno)
|| i386_mxcsr_regnum_p (current_gdbarch, regno))
{
i386_float_state_t fp_regs;
unsigned int fp_count = i386_FLOAT_STATE_COUNT;
kern_return_t 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);
}
i386_darwin_fetch_fp_registers (regcache, &fp_regs);
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 regcache *regcache, int
regno)
{
int current_pid;
thread_t current_thread;
current_pid = ptid_get_pid (inferior_ptid);
current_thread = ptid_get_tid (inferior_ptid);
validate_inferior_registers (regcache, regno);
if (gdbarch_ptr_bit (current_gdbarch) == 64)
{
if ((regno == -1) || IS_GP_REGNUM_64 (regno))
{
x86_thread_state_t gp_regs;
kern_return_t ret;
gp_regs.tsh.flavor = x86_THREAD_STATE64;
gp_regs.tsh.count = x86_THREAD_STATE64_COUNT;
amd64_darwin_store_gp_registers (regcache,
&gp_regs.uts.ts64);
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)
|| IS_FP_REGNUM_64 (regno)
|| IS_VP_REGNUM_64 (regno))
{
x86_float_state_t fp_regs;
kern_return_t ret;
fp_regs.fsh.flavor = x86_FLOAT_STATE64;
fp_regs.fsh.count = x86_FLOAT_STATE64_COUNT;
if (amd64_darwin_store_fp_registers (regcache,
&fp_regs.ufs.fs64))
{
ret = thread_set_state (current_thread, x86_FLOAT_STATE,
(thread_state_t) & fp_regs,
x86_FLOAT_STATE_COUNT);
MACH_CHECK_ERROR (ret);
}
}
}
else
{
if ((regno == -1) || IS_GP_REGNUM (regno))
{
i386_thread_state_t gp_regs;
kern_return_t ret;
i386_darwin_store_gp_registers (regcache, &gp_regs);
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)
|| IS_FP_REGNUM (regno)
|| i386_sse_regnum_p (current_gdbarch, regno)
|| i386_mxcsr_regnum_p (current_gdbarch, regno))
{
i386_float_state_t fp_regs;
kern_return_t ret;
if (i386_darwin_store_fp_registers (regcache, &fp_regs))
{
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)
{
#ifndef HAVE_X86_DEBUG_STATE32_T
return;
#else
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_pid = ptid_get_pid (inferior_ptid);
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);
}
#endif /* HAVE_X86_DEBUG_STATE32_T */
}
static uint32_t
i386_darwin_dr_get (int regnum)
{
#ifndef HAVE_X86_DEBUG_STATE32_T
return -1;
#else
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_pid = ptid_get_pid (inferior_ptid);
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;
}
#endif /* HAVE_X86_DEBUG_STATE32_T */
}
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_complete_target (struct target_ops *target)
{
target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
target->to_store_registers = i386_darwin_store_inferior_registers;
}
^ permalink raw reply [flat|nested] 3+ messages in thread* Re: [RFA] Darwin/x86 port (v4 - part 3/4: i386-darwin files)
2008-11-14 18:43 [RFA] Darwin/x86 port (v4 - part 3/4: i386-darwin files) Tristan Gingold
@ 2008-11-19 1:47 ` Stan Shebs
2008-11-19 22:53 ` Tristan Gingold
0 siblings, 1 reply; 3+ messages in thread
From: Stan Shebs @ 2008-11-19 1:47 UTC (permalink / raw)
To: Tristan Gingold; +Cc: gdb-patches
Tristan Gingold wrote:
> i386-darwin-tdep.h:
>
>
> #include <mach/thread_status.h>
This code is a little mixed up, I've been studying the situation but am
not yet sure how to proceed.
The high-order bit is that we can't allow native-only headers to be
included into *-tdep.c files - they must be able to be compiled on any
host. One either precalculates offsets and such and uses, or defines
lookalike structs. The alternative is to move code into a nat.c file.
Given that Apple's GDB isn't correctly set up to be a cross-debugger
either, the easiest path is to migrate code into i386-darwin-nat.c .
When you can compile i386-darwin-tdep.c on a Sparc Linux host, you're
done. :-)
The other thing that is problematic is the large-scale use of macros
like FIRST_GP_REGNUM and friends. This is an unfortunate consequence of
being diverged from FSF for so long - this method of handling registers
was left behind years ago, and has only survived in Apple's GDB due to
inertia. Even though the files are isolated into being Darwin-specific,
it still brings obsolete technique back into the trunk, confusing
developers and increasing support burden.
So since a bunch of code has to be moved anyway, I'd like you to take
the opportunity to look at regsets as used in i386-linux-nat.c and
i386-linux-tdep.c and see how much work it would be to switch over. I
think you'll find it a win, and that a lot of this code will simply go away.
Stan
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [RFA] Darwin/x86 port (v4 - part 3/4: i386-darwin files)
2008-11-19 1:47 ` Stan Shebs
@ 2008-11-19 22:53 ` Tristan Gingold
0 siblings, 0 replies; 3+ messages in thread
From: Tristan Gingold @ 2008-11-19 22:53 UTC (permalink / raw)
To: Stan Shebs; +Cc: gdb-patches
On Nov 18, 2008, at 9:37 PM, Stan Shebs wrote:
> Tristan Gingold wrote:
>> i386-darwin-tdep.h:
>>
>>
>> #include <mach/thread_status.h>
> This code is a little mixed up, I've been studying the situation but
> am not yet sure how to proceed.
>
> The high-order bit is that we can't allow native-only headers to be
> included into *-tdep.c files - they must be able to be compiled on
> any host. One either precalculates offsets and such and uses, or
> defines lookalike structs. The alternative is to move code into a
> nat.c file. Given that Apple's GDB isn't correctly set up to be a
> cross-debugger either, the easiest path is to migrate code into i386-
> darwin-nat.c . When you can compile i386-darwin-tdep.c on a Sparc
> Linux host, you're done. :-)
I have migrated all the register stuff to i386-darwin-nat.c which
makes i386-darwin-tdep.c much smaller.
I haven't checked it could be compiled on Sparc Linux (as I don't have
access to such a machine :-) but
looking at the file it should be.
> The other thing that is problematic is the large-scale use of macros
> like FIRST_GP_REGNUM and friends. This is an unfortunate
> consequence of being diverged from FSF for so long - this method of
> handling registers was left behind years ago, and has only survived
> in Apple's GDB due to inertia. Even though the files are isolated
> into being Darwin-specific, it still brings obsolete technique back
> into the trunk, confusing developers and increasing support burden.
>
>
> So since a bunch of code has to be moved anyway, I'd like you to
> take the opportunity to look at regsets as used in i386-linux-nat.c
> and i386-linux-tdep.c and see how much work it would be to switch
> over. I think you'll find it a win, and that a lot of this code will
> simply go away.
I have looked at i386-linux-nat.c and amd64-linux-nat.c and switched
over. This makes the code smaller
(and much different from Apple's GDB).
Thank you very much for pointing this issue. Very useful to improve
the code.
Tristan.
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2008-11-19 12:49 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-11-14 18:43 [RFA] Darwin/x86 port (v4 - part 3/4: i386-darwin files) Tristan Gingold
2008-11-19 1:47 ` Stan Shebs
2008-11-19 22:53 ` Tristan Gingold
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox