From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 21819 invoked by alias); 12 Nov 2008 12:53:00 -0000 Received: (qmail 21241 invoked by uid 22791); 12 Nov 2008 12:52:54 -0000 X-Spam-Check-By: sourceware.org Received: from ulanbator.act-europe.fr (HELO ulanbator.act-europe.fr) (212.99.106.139) by sourceware.org (qpsmtpd/0.31) with ESMTP; Wed, 12 Nov 2008 12:51:52 +0000 Received: by ulanbator.act-europe.fr (Postfix, from userid 501) id 564397B25DB; Wed, 12 Nov 2008 13:51:50 +0100 (CET) Date: Wed, 12 Nov 2008 19:10:00 -0000 From: Tristan Gingold To: gdb-patches@sourceware.org Subject: [RFA] Darwin/x86 port (v3 of part 3: i386-darwin files) Message-ID: <20081112125150.GA21514@ulanbator.act-europe.fr> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.4.2.3i X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2008-11/txt/msg00237.txt.bz2 Message-ID: <20081112191000.0VJghXJTO4ISCJHalPRFxfM2Lwt1WWHFT3yH32_coa0@z> 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 . */ #ifndef __I386_DARWIN_TDEP_H__ #define __I386_DARWIN_TDEP_H__ #include #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 . */ #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 #include #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 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 . */ #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 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 ("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 ("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 ("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 ("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; }