[deliverable/binutils-gdb.git] / gdb / 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 "amd64-nat.h"
#include "i387-tdep.h"
#include "gdbarch.h"
#include "arch-utils.h"

#include "darwin-nat.h"
#include "i386-darwin-tdep.h"

/* 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)
{
  thread_t current_thread = ptid_get_tid (inferior_ptid);
  int fetched = 0;
  struct gdbarch *gdbarch = get_regcache_arch (regcache);

  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);
	    }
          i387_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64);
          fetched++;
        }
    }
  else
    {
      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 regcache *regcache, int regno)
{
  thread_t current_thread = ptid_get_tid (inferior_ptid);
  struct gdbarch *gdbarch = get_regcache_arch (regcache);

  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);

	  i387_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
    {
      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 (current_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 (current_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

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 ((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;
    case x86_THREAD_STATE64:
      {
	__uint64_t bit = enable ? X86_EFLAGS_T : 0;

	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;
    default:
      error (_("darwin_set_sstep: unknown flavour: %d\n"), regs.tsh.flavor);
    }
}

void
darwin_complete_target (struct target_ops *target)
{
  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;

  target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
  target->to_store_registers = i386_darwin_store_inferior_registers;
}
Commit	Line	Data
a80b95ba TG	1	/* Darwin support for GDB, the GNU debugger.
	2	Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2008
	3	Free Software Foundation, Inc.
	4
	5	Contributed by Apple Computer, Inc.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 3 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	21
	22	#include "defs.h"
	23	#include "frame.h"
	24	#include "inferior.h"
	25	#include "target.h"
	26	#include "symfile.h"
	27	#include "symtab.h"
	28	#include "objfiles.h"
	29	#include "gdbcmd.h"
	30	#include "regcache.h"
	31	#include "gdb_assert.h"
	32	#include "i386-tdep.h"
	33	#include "amd64-nat.h"
	34	#include "i387-tdep.h"
	35	#include "gdbarch.h"
	36	#include "arch-utils.h"
	37
	38	#include "darwin-nat.h"
	39	#include "i386-darwin-tdep.h"
	40
	41	/* Read register values from the inferior process.
	42	If REGNO is -1, do this for all registers.
	43	Otherwise, REGNO specifies which register (so we can save time). */
	44	static void
	45	i386_darwin_fetch_inferior_registers (struct regcache *regcache, int regno)
	46	{
	47	thread_t current_thread = ptid_get_tid (inferior_ptid);
	48	int fetched = 0;
	49	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	50
	51	if (gdbarch_ptr_bit (gdbarch) == 64)
	52	{
	53	if (regno == -1 \|\| amd64_native_gregset_supplies_p (gdbarch, regno))
	54	{
	55	x86_thread_state_t gp_regs;
	56	unsigned int gp_count = x86_THREAD_STATE_COUNT;
	57	kern_return_t ret;
	58
	59	ret = thread_get_state
	60	(current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
	61	&gp_count);
	62	if (ret != KERN_SUCCESS)
	63	{
	64	printf_unfiltered (_("Error calling thread_get_state for GP registers for thread 0x%ulx"), current_thread);
65	MACH_CHECK_ERROR (ret);
66	}
67	amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
68	fetched++;
69	}
70
71	if (regno == -1 \|\| !amd64_native_gregset_supplies_p (gdbarch, regno))
72	{
73	x86_float_state_t fp_regs;
74	unsigned int fp_count = x86_FLOAT_STATE_COUNT;
75	kern_return_t ret;
76
77	ret = thread_get_state
78	(current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
79	&fp_count);
80	if (ret != KERN_SUCCESS)
81	{
82	printf_unfiltered (_("Error calling thread_get_state for float registers for thread 0x%ulx"), current_thread);
83	MACH_CHECK_ERROR (ret);
84	}
85	i387_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64);
86	fetched++;
87	}
88	}
89	else
90	{
91	if (regno == -1 \|\| regno < I386_NUM_GREGS)
92	{
93	i386_thread_state_t gp_regs;
94	unsigned int gp_count = i386_THREAD_STATE_COUNT;
95	kern_return_t ret;
96	int i;
97
98	ret = thread_get_state
99	(current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
100	&gp_count);
101	if (ret != KERN_SUCCESS)
102	{
103	printf_unfiltered (_("Error calling thread_get_state for GP registers for thread 0x%ulx"), current_thread);
104	MACH_CHECK_ERROR (ret);
105	}
106	for (i = 0; i < I386_NUM_GREGS; i++)
107	regcache_raw_supply
108	(regcache, i,
109	(char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
110
111	fetched++;
112	}
113
114	if (regno == -1
115	\|\| (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
116	{
117	i386_float_state_t fp_regs;
118	unsigned int fp_count = i386_FLOAT_STATE_COUNT;
119	kern_return_t ret;
120
121	ret = thread_get_state
122	(current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
123	&fp_count);
124	if (ret != KERN_SUCCESS)
125	{
126	printf_unfiltered (_("Error calling thread_get_state for float registers for thread 0x%ulx"), current_thread);
127	MACH_CHECK_ERROR (ret);
128	}
129	i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
130	fetched++;
131	}
132	}
133
134	if (! fetched)
135	{
136	warning (_("unknown register %d"), regno);
137	regcache_raw_supply (regcache, regno, NULL);
138	}
139	}
140
141	/* Store our register values back into the inferior.
142	If REGNO is -1, do this for all registers.
143	Otherwise, REGNO specifies which register (so we can save time). */
144
145	static void
146	i386_darwin_store_inferior_registers (struct regcache *regcache, int regno)
147	{
148	thread_t current_thread = ptid_get_tid (inferior_ptid);
149	struct gdbarch *gdbarch = get_regcache_arch (regcache);
150
151	if (gdbarch_ptr_bit (gdbarch) == 64)
152	{
153	if (regno == -1 \|\| amd64_native_gregset_supplies_p (gdbarch, regno))
154	{
155	x86_thread_state_t gp_regs;
156	kern_return_t ret;
157	unsigned int gp_count = x86_THREAD_STATE_COUNT;
158
159	ret = thread_get_state
160	(current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs,
161	&gp_count);
162	MACH_CHECK_ERROR (ret);
163	gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64);
164	gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT);
165
166	amd64_collect_native_gregset (regcache, &gp_regs.uts, regno);
167
168	ret = thread_set_state (current_thread, x86_THREAD_STATE,
169	(thread_state_t) &gp_regs,
170	x86_THREAD_STATE_COUNT);
171	MACH_CHECK_ERROR (ret);
172	}
173
174	if (regno == -1 \|\| !amd64_native_gregset_supplies_p (gdbarch, regno))
175	{
176	x86_float_state_t fp_regs;
177	kern_return_t ret;
178	unsigned int fp_count = x86_FLOAT_STATE_COUNT;
179
180	ret = thread_get_state
181	(current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
182	&fp_count);
183	MACH_CHECK_ERROR (ret);
184	gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64);
185	gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT);
186
187	i387_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw);
188
189	ret = thread_set_state (current_thread, x86_FLOAT_STATE,
190	(thread_state_t) & fp_regs,
191	x86_FLOAT_STATE_COUNT);
192	MACH_CHECK_ERROR (ret);
193	}
194	}
195	else
196	{
197	if (regno == -1 \|\| regno < I386_NUM_GREGS)
198	{
199	i386_thread_state_t gp_regs;
200	kern_return_t ret;
201	unsigned int gp_count = i386_THREAD_STATE_COUNT;
202	int i;
203
204	ret = thread_get_state
205	(current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
206	&gp_count);
207	MACH_CHECK_ERROR (ret);
208
209	for (i = 0; i < I386_NUM_GREGS; i++)
210	if (regno == -1 \|\| regno == i)
211	regcache_raw_collect
212	(regcache, i,
213	(char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
214
215	ret = thread_set_state (current_thread, i386_THREAD_STATE,
216	(thread_state_t) & gp_regs,
217	i386_THREAD_STATE_COUNT);
218	MACH_CHECK_ERROR (ret);
219	}
220
221	if (regno == -1
222	\|\| (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
223	{
224	i386_float_state_t fp_regs;
225	unsigned int fp_count = i386_FLOAT_STATE_COUNT;
226	kern_return_t ret;
227
228	ret = thread_get_state
229	(current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
230	&fp_count);
231	MACH_CHECK_ERROR (ret);
232
233	i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw);
234
235	ret = thread_set_state (current_thread, i386_FLOAT_STATE,
236	(thread_state_t) & fp_regs,
237	i386_FLOAT_STATE_COUNT);
238	MACH_CHECK_ERROR (ret);
239	}
240	}
241	}
242
243
244	/* Support for debug registers, boosted mostly from i386-linux-nat.c. */
245
246	#ifndef DR_FIRSTADDR
247	#define DR_FIRSTADDR 0
248	#endif
249
250	#ifndef DR_LASTADDR
251	#define DR_LASTADDR 3
252	#endif
253
254	#ifndef DR_STATUS
255	#define DR_STATUS 6
256	#endif
257
258	#ifndef DR_CONTROL
259	#define DR_CONTROL 7
260	#endif
261
262
263	static void
264	i386_darwin_dr_set (int regnum, uint32_t value)
265	{
266	int current_pid;
267	thread_t current_thread;
268	x86_debug_state_t dr_regs;
269	kern_return_t ret;
270	unsigned int dr_count = x86_DEBUG_STATE_COUNT;
271
272	gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
273
274	current_thread = ptid_get_tid (inferior_ptid);
275
276	dr_regs.dsh.flavor = x86_DEBUG_STATE32;
277	dr_regs.dsh.count = x86_DEBUG_STATE32_COUNT;
278	dr_count = x86_DEBUG_STATE_COUNT;
279	ret = thread_get_state (current_thread, x86_DEBUG_STATE,
280	(thread_state_t) &dr_regs, &dr_count);
281
282	if (ret != KERN_SUCCESS)
283	{
284	printf_unfiltered (_("Error reading debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
285	MACH_CHECK_ERROR (ret);
286	}
287
288	switch (regnum)
289	{
290	case 0:
291	dr_regs.uds.ds32.__dr0 = value;
292	break;
293	case 1:
294	dr_regs.uds.ds32.__dr1 = value;
295	break;
296	case 2:
297	dr_regs.uds.ds32.__dr2 = value;
298	break;
299	case 3:
300	dr_regs.uds.ds32.__dr3 = value;
301	break;
302	case 4:
303	dr_regs.uds.ds32.__dr4 = value;
304	break;
305	case 5:
306	dr_regs.uds.ds32.__dr5 = value;
307	break;
308	case 6:
309	dr_regs.uds.ds32.__dr6 = value;
310	break;
311	case 7:
312	dr_regs.uds.ds32.__dr7 = value;
313	break;
314	}
315
316	ret = thread_set_state (current_thread, x86_DEBUG_STATE,
317	(thread_state_t) &dr_regs, dr_count);
318
319	if (ret != KERN_SUCCESS)
320	{
321	printf_unfiltered (_("Error writing debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
322	MACH_CHECK_ERROR (ret);
323	}
324	}
325
326	static uint32_t
327	i386_darwin_dr_get (int regnum)
328	{
329	thread_t current_thread;
330	x86_debug_state_t dr_regs;
331	kern_return_t ret;
332	unsigned int dr_count = x86_DEBUG_STATE_COUNT;
333
334	gdb_assert (regnum >= 0 && regnum <= DR_CONTROL);
335
336	current_thread = ptid_get_tid (inferior_ptid);
337
338	dr_regs.dsh.flavor = x86_DEBUG_STATE32;
339	dr_regs.dsh.count = x86_DEBUG_STATE32_COUNT;
340	dr_count = x86_DEBUG_STATE_COUNT;
341	ret = thread_get_state (current_thread, x86_DEBUG_STATE,
342	(thread_state_t) &dr_regs, &dr_count);
343
344	if (ret != KERN_SUCCESS)
345	{
346	printf_unfiltered (_("Error reading debug registers thread 0x%x via thread_get_state\n"), (int) current_thread);
347	MACH_CHECK_ERROR (ret);
348	}
349
350	switch (regnum)
351	{
352	case 0:
353	return dr_regs.uds.ds32.__dr0;
354	case 1:
355	return dr_regs.uds.ds32.__dr1;
356	case 2:
357	return dr_regs.uds.ds32.__dr2;
358	case 3:
359	return dr_regs.uds.ds32.__dr3;
360	case 4:
361	return dr_regs.uds.ds32.__dr4;
362	case 5:
363	return dr_regs.uds.ds32.__dr5;
364	case 6:
365	return dr_regs.uds.ds32.__dr6;
366	case 7:
367	return dr_regs.uds.ds32.__dr7;
368	default:
369	return -1;
370	}
371	}
372
373	void
374	i386_darwin_dr_set_control (unsigned long control)
375	{
376	i386_darwin_dr_set (DR_CONTROL, control);
377	}
378
379	void
380	i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr)
381	{
382	gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
383
384	i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr);
385	}
386
387	void
388	i386_darwin_dr_reset_addr (int regnum)
389	{
390	gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
391
392	i386_darwin_dr_set (DR_FIRSTADDR + regnum, 0L);
393	}
394
395	unsigned long
396	i386_darwin_dr_get_status (void)
397	{
398	return i386_darwin_dr_get (DR_STATUS);
399	}
400
401	void
402	darwin_check_osabi (darwin_inferior *inf, thread_t thread)
403	{
404	if (gdbarch_osabi (current_gdbarch) == GDB_OSABI_UNKNOWN)
405	{
406	/* Attaching to a process. Let's figure out what kind it is. */
407	x86_thread_state_t gp_regs;
408	struct gdbarch_info info;
409	unsigned int gp_count = x86_THREAD_STATE_COUNT;
410	kern_return_t ret;
411
412	ret = thread_get_state (thread, x86_THREAD_STATE,
413	(thread_state_t) &gp_regs, &gp_count);
414	if (ret != KERN_SUCCESS)
415	{
416	MACH_CHECK_ERROR (ret);
417	return;
418	}
419
420	gdbarch_info_init (&info);
421	gdbarch_info_fill (&info);
422	info.byte_order = gdbarch_byte_order (current_gdbarch);
423	info.osabi = GDB_OSABI_DARWIN;
424	if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
425	info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
426	bfd_mach_x86_64);
427	else
428	info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
429	bfd_mach_i386_i386);
430	gdbarch_update_p (info);
431	}
432	}
433
434	#define X86_EFLAGS_T 0x100UL
435
436	void
437	darwin_set_sstep (thread_t thread, int enable)
438	{
439	x86_thread_state_t regs;
440	unsigned int count = x86_THREAD_STATE_COUNT;
441	kern_return_t kret;
442
443	kret = thread_get_state (thread, x86_THREAD_STATE,
444	(thread_state_t) &regs, &count);
445	if (kret != KERN_SUCCESS)
446	{
447	printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"),
448	kret, thread);
449	return;
450	}
451	switch (regs.tsh.flavor)
452	{
453	case x86_THREAD_STATE32:
454	{
455	__uint32_t bit = enable ? X86_EFLAGS_T : 0;
456
457	if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit)
458	return;
459	regs.uts.ts32.__eflags = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) \| bit;
460	kret = thread_set_state (thread, x86_THREAD_STATE,
461	(thread_state_t) &regs, count);
462	MACH_CHECK_ERROR (kret);
463	}
464	break;
465	case x86_THREAD_STATE64:
466	{
467	__uint64_t bit = enable ? X86_EFLAGS_T : 0;
468
469	if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit)
470	return;
471	regs.uts.ts64.__rflags = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) \| bit;
472	kret = thread_set_state (thread, x86_THREAD_STATE,
473	(thread_state_t) &regs, count);
474	MACH_CHECK_ERROR (kret);
475	}
476	break;
477	default:
478	error (_("darwin_set_sstep: unknown flavour: %d\n"), regs.tsh.flavor);
479	}
480	}
481
482	void
483	darwin_complete_target (struct target_ops *target)
484	{
485	amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
486	amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs;
487	amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset;
488	amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs;
489
490	target->to_fetch_registers = i386_darwin_fetch_inferior_registers;
491	target->to_store_registers = i386_darwin_store_inferior_registers;
492	}