This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFA] Darwin/x86 port (v3 of part 3: i386-darwin files)


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 ("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;
}


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]