[deliverable/binutils-gdb.git] / gdb / i386-gnu-nat.c

/* Low level interface to i386 running the GNU Hurd.

   Copyright (C) 1992-2018 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/>.  */

/* Mach/Hurd headers are not yet ready for C++ compilation.  */
extern "C"
{
#include <mach.h>
#include <mach_error.h>
#include <mach/message.h>
#include <mach/exception.h>
}

#include "defs.h"
#include "x86-nat.h"
#include "inferior.h"
#include "floatformat.h"
#include "regcache.h"

#include "i386-tdep.h"

#include "gnu-nat.h"
#include "inf-child.h"
#include "i387-tdep.h"

/* Offset to the thread_state_t location where REG is stored.  */
#define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg)

/* At REG_OFFSET[N] is the offset to the thread_state_t location where
   the GDB register N is stored.  */
static int reg_offset[] =
{
  REG_OFFSET (eax), REG_OFFSET (ecx), REG_OFFSET (edx), REG_OFFSET (ebx),
  REG_OFFSET (uesp), REG_OFFSET (ebp), REG_OFFSET (esi), REG_OFFSET (edi),
  REG_OFFSET (eip), REG_OFFSET (efl), REG_OFFSET (cs), REG_OFFSET (ss),
  REG_OFFSET (ds), REG_OFFSET (es), REG_OFFSET (fs), REG_OFFSET (gs)
};

#define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])

\f

/* The i386 GNU Hurd target.  */

#ifdef i386_DEBUG_STATE
using gnu_base_target = x86_nat_target<gnu_nat_target>;
#else
using gnu_base_target = gnu_nat_target;
#endif

struct i386_gnu_nat_target final : public gnu_base_target
{
  void fetch_registers (struct regcache *, int) override;
  void store_registers (struct regcache *, int) override;
};

static i386_gnu_nat_target the_i386_gnu_nat_target;

/* Get the whole floating-point state of THREAD and record the values
   of the corresponding (pseudo) registers.  */

static void
fetch_fpregs (struct regcache *regcache, struct proc *thread)
{
  mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
  struct i386_float_state state;
  kern_return_t err;

  err = thread_get_state (thread->port, i386_FLOAT_STATE,
			  (thread_state_t) &state, &count);
  if (err)
    {
      warning (_("Couldn't fetch floating-point state from %s"),
	       proc_string (thread));
      return;
    }

  if (!state.initialized)
    {
      /* The floating-point state isn't initialized.  */
      i387_supply_fsave (regcache, -1, NULL);
    }
  else
    {
      /* Supply the floating-point registers.  */
      i387_supply_fsave (regcache, -1, state.hw_state);
    }
}

/* Fetch register REGNO, or all regs if REGNO is -1.  */
static void
gnu_fetch_registers (struct target_ops *ops,
		     struct regcache *regcache, int regno)
{
  struct proc *thread;
  ptid_t ptid = regcache_get_ptid (regcache);

  /* Make sure we know about new threads.  */
  inf_update_procs (gnu_current_inf);

  thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
  if (!thread)
    error (_("Can't fetch registers from thread %s: No such thread"),
	   target_pid_to_str (ptid));

  if (regno < I386_NUM_GREGS || regno == -1)
    {
      thread_state_t state;

      /* This does the dirty work for us.  */
      state = proc_get_state (thread, 0);
      if (!state)
	{
	  warning (_("Couldn't fetch registers from %s"),
		   proc_string (thread));
	  return;
	}

      if (regno == -1)
	{
	  int i;

	  proc_debug (thread, "fetching all register");

	  for (i = 0; i < I386_NUM_GREGS; i++)
	    regcache_raw_supply (regcache, i, REG_ADDR (state, i));
	  thread->fetched_regs = ~0;
	}
      else
	{
	  proc_debug (thread, "fetching register %s",
		      gdbarch_register_name (regcache->arch (),
					     regno));

	  regcache_raw_supply (regcache, regno,
			       REG_ADDR (state, regno));
	  thread->fetched_regs |= (1 << regno);
	}
    }

  if (regno >= I386_NUM_GREGS || regno == -1)
    {
      proc_debug (thread, "fetching floating-point registers");

      fetch_fpregs (regcache, thread);
    }
}
\f

/* Store the whole floating-point state into THREAD using information
   from the corresponding (pseudo) registers.  */
static void
store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
{
  mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
  struct i386_float_state state;
  kern_return_t err;

  err = thread_get_state (thread->port, i386_FLOAT_STATE,
			  (thread_state_t) &state, &count);
  if (err)
    {
      warning (_("Couldn't fetch floating-point state from %s"),
	       proc_string (thread));
      return;
    }

  /* FIXME: kettenis/2001-07-15: Is this right?  Should we somehow
     take into account DEPRECATED_REGISTER_VALID like the old code did?  */
  i387_collect_fsave (regcache, regno, state.hw_state);

  err = thread_set_state (thread->port, i386_FLOAT_STATE,
			  (thread_state_t) &state, i386_FLOAT_STATE_COUNT);
  if (err)
    {
      warning (_("Couldn't store floating-point state into %s"),
	       proc_string (thread));
      return;
    }
}

/* Store at least register REGNO, or all regs if REGNO == -1.  */
static void
gnu_store_registers (struct target_ops *ops,
		     struct regcache *regcache, int regno)
{
  struct proc *thread;
  struct gdbarch *gdbarch = regcache->arch ();
  ptid_t ptid = regcache_get_ptid (regcache);

  /* Make sure we know about new threads.  */
  inf_update_procs (gnu_current_inf);

  thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
  if (!thread)
    error (_("Couldn't store registers into thread %s: No such thread"),
	   target_pid_to_str (ptid));

  if (regno < I386_NUM_GREGS || regno == -1)
    {
      thread_state_t state;
      thread_state_data_t old_state;
      int was_aborted = thread->aborted;
      int was_valid = thread->state_valid;
      int trace;

      if (!was_aborted && was_valid)
	memcpy (&old_state, &thread->state, sizeof (old_state));

      state = proc_get_state (thread, 1);
      if (!state)
	{
	  warning (_("Couldn't store registers into %s"),
		   proc_string (thread));
	  return;
	}

      /* Save the T bit.  We might try to restore the %eflags register
         below, but changing the T bit would seriously confuse GDB.  */
      trace = ((struct i386_thread_state *)state)->efl & 0x100;

      if (!was_aborted && was_valid)
	/* See which registers have changed after aborting the thread.  */
	{
	  int check_regno;

	  for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
	    if ((thread->fetched_regs & (1 << check_regno))
		&& memcpy (REG_ADDR (&old_state, check_regno),
			   REG_ADDR (state, check_regno),
			   register_size (gdbarch, check_regno)))
	      /* Register CHECK_REGNO has changed!  Ack!  */
	      {
		warning (_("Register %s changed after the thread was aborted"),
			 gdbarch_register_name (gdbarch, check_regno));
		if (regno >= 0 && regno != check_regno)
		  /* Update GDB's copy of the register.  */
		  regcache_raw_supply (regcache, check_regno,
				       REG_ADDR (state, check_regno));
		else
		  warning (_("... also writing this register!  "
			     "Suspicious..."));
	      }
	}

      if (regno == -1)
	{
	  int i;

	  proc_debug (thread, "storing all registers");

	  for (i = 0; i < I386_NUM_GREGS; i++)
	    if (REG_VALID == regcache_register_status (regcache, i))
	      regcache_raw_collect (regcache, i, REG_ADDR (state, i));
	}
      else
	{
	  proc_debug (thread, "storing register %s",
		      gdbarch_register_name (gdbarch, regno));

	  gdb_assert (REG_VALID == regcache_register_status (regcache, regno));
	  regcache_raw_collect (regcache, regno, REG_ADDR (state, regno));
	}

      /* Restore the T bit.  */
      ((struct i386_thread_state *)state)->efl &= ~0x100;
      ((struct i386_thread_state *)state)->efl |= trace;
    }

  if (regno >= I386_NUM_GREGS || regno == -1)
    {
      proc_debug (thread, "storing floating-point registers");

      store_fpregs (regcache, thread, regno);
    }
}

\f
/* Support for debug registers.  */

#ifdef i386_DEBUG_STATE
/* Get debug registers for thread THREAD.  */

static void
i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread)
{
  mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT;
  kern_return_t err;

  err = thread_get_state (thread->port, i386_DEBUG_STATE,
			  (thread_state_t) regs, &count);
  if (err != 0 || count != i386_DEBUG_STATE_COUNT)
    warning (_("Couldn't fetch debug state from %s"),
	     proc_string (thread));
}

/* Set debug registers for thread THREAD.  */

static void
i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread)
{
  kern_return_t err;

  err = thread_set_state (thread->port, i386_DEBUG_STATE,
			  (thread_state_t) regs, i386_DEBUG_STATE_COUNT);
  if (err != 0)
    warning (_("Couldn't store debug state into %s"),
	     proc_string (thread));
}

/* Set DR_CONTROL in THREAD.  */

static void
i386_gnu_dr_set_control_one (struct proc *thread, void *arg)
{
  unsigned long *control = (unsigned long *) arg;
  struct i386_debug_state regs;

  i386_gnu_dr_get (&regs, thread);
  regs.dr[DR_CONTROL] = *control;
  i386_gnu_dr_set (&regs, thread);
}

/* Set DR_CONTROL to CONTROL in all threads.  */

static void
i386_gnu_dr_set_control (unsigned long control)
{
  inf_update_procs (gnu_current_inf);
  inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control);
}

/* Parameters to set a debugging address.  */

struct reg_addr
{
  int regnum;		/* Register number (zero based).  */
  CORE_ADDR addr;	/* Address.  */
};

/* Set address REGNUM (zero based) to ADDR in THREAD.  */

static void
i386_gnu_dr_set_addr_one (struct proc *thread, void *arg)
{
  struct reg_addr *reg_addr = (struct reg_addr *) arg;
  struct i386_debug_state regs;

  i386_gnu_dr_get (&regs, thread);
  regs.dr[reg_addr->regnum] = reg_addr->addr;
  i386_gnu_dr_set (&regs, thread);
}

/* Set address REGNUM (zero based) to ADDR in all threads.  */

static void
i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr)
{
  struct reg_addr reg_addr;

  gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);

  reg_addr.regnum = regnum;
  reg_addr.addr = addr;

  inf_update_procs (gnu_current_inf);
  inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, &reg_addr);
}

/* Get debug register REGNUM value from only the one LWP of PTID.  */

static unsigned long
i386_gnu_dr_get_reg (ptid_t ptid, int regnum)
{
  struct i386_debug_state regs;
  struct proc *thread;

  /* Make sure we know about new threads.  */
  inf_update_procs (gnu_current_inf);

  thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
  i386_gnu_dr_get (&regs, thread);

  return regs.dr[regnum];
}

/* Return the inferior's debug register REGNUM.  */

static CORE_ADDR
i386_gnu_dr_get_addr (int regnum)
{
  gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);

  return i386_gnu_dr_get_reg (inferior_ptid, regnum);
}

/* Get DR_STATUS from only the one thread of INFERIOR_PTID.  */

static unsigned long
i386_gnu_dr_get_status (void)
{
  return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS);
}

/* Return the inferior's DR7 debug control register.  */

static unsigned long
i386_gnu_dr_get_control (void)
{
  return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL);
}
#endif /* i386_DEBUG_STATE */

void
_initialize_i386gnu_nat (void)
{
#ifdef i386_DEBUG_STATE
  x86_dr_low.set_control = i386_gnu_dr_set_control;
  gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT);
  x86_dr_low.set_addr = i386_gnu_dr_set_addr;
  x86_dr_low.get_addr = i386_gnu_dr_get_addr;
  x86_dr_low.get_status = i386_gnu_dr_get_status;
  x86_dr_low.get_control = i386_gnu_dr_get_control;
  x86_set_debug_register_length (4);
#endif /* i386_DEBUG_STATE */

  /* Register the target.  */
  add_inf_child_target (&the_i386_gnu_nat_target);
}
Commit	Line	Data
	1	/* Low level interface to i386 running the GNU Hurd.
	2
	3	Copyright (C) 1992-2018 Free Software Foundation, Inc.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	/* Mach/Hurd headers are not yet ready for C++ compilation. */
	21	extern "C"
	22	{
	23	#include <mach.h>
	24	#include <mach_error.h>
	25	#include <mach/message.h>
	26	#include <mach/exception.h>
	27	}
	28
	29	#include "defs.h"
	30	#include "x86-nat.h"
	31	#include "inferior.h"
	32	#include "floatformat.h"
	33	#include "regcache.h"
	34
	35	#include "i386-tdep.h"
	36
	37	#include "gnu-nat.h"
	38	#include "inf-child.h"
	39	#include "i387-tdep.h"
	40
	41	/* Offset to the thread_state_t location where REG is stored. */
	42	#define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg)
	43
	44	/* At REG_OFFSET[N] is the offset to the thread_state_t location where
	45	the GDB register N is stored. */
	46	static int reg_offset[] =
	47	{
	48	REG_OFFSET (eax), REG_OFFSET (ecx), REG_OFFSET (edx), REG_OFFSET (ebx),
	49	REG_OFFSET (uesp), REG_OFFSET (ebp), REG_OFFSET (esi), REG_OFFSET (edi),
	50	REG_OFFSET (eip), REG_OFFSET (efl), REG_OFFSET (cs), REG_OFFSET (ss),
	51	REG_OFFSET (ds), REG_OFFSET (es), REG_OFFSET (fs), REG_OFFSET (gs)
	52	};
	53
	54	#define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])
	55
	56	\f
	57
	58	/* The i386 GNU Hurd target. */
	59
	60	#ifdef i386_DEBUG_STATE
	61	using gnu_base_target = x86_nat_target<gnu_nat_target>;
	62	#else
	63	using gnu_base_target = gnu_nat_target;
	64	#endif
	65
	66	struct i386_gnu_nat_target final : public gnu_base_target
	67	{
	68	void fetch_registers (struct regcache *, int) override;
	69	void store_registers (struct regcache *, int) override;
	70	};
	71
	72	static i386_gnu_nat_target the_i386_gnu_nat_target;
	73
	74	/* Get the whole floating-point state of THREAD and record the values
	75	of the corresponding (pseudo) registers. */
	76
	77	static void
	78	fetch_fpregs (struct regcache regcache, struct proc thread)
	79	{
	80	mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
	81	struct i386_float_state state;
	82	kern_return_t err;
	83
	84	err = thread_get_state (thread->port, i386_FLOAT_STATE,
	85	(thread_state_t) &state, &count);
	86	if (err)
	87	{
	88	warning (_("Couldn't fetch floating-point state from %s"),
	89	proc_string (thread));
	90	return;
	91	}
	92
	93	if (!state.initialized)
	94	{
	95	/* The floating-point state isn't initialized. */
	96	i387_supply_fsave (regcache, -1, NULL);
	97	}
	98	else
	99	{
	100	/* Supply the floating-point registers. */
	101	i387_supply_fsave (regcache, -1, state.hw_state);
	102	}
	103	}
	104
	105	/* Fetch register REGNO, or all regs if REGNO is -1. */
	106	static void
	107	gnu_fetch_registers (struct target_ops *ops,
	108	struct regcache *regcache, int regno)
	109	{
	110	struct proc *thread;
	111	ptid_t ptid = regcache_get_ptid (regcache);
	112
	113	/* Make sure we know about new threads. */
	114	inf_update_procs (gnu_current_inf);
	115
	116	thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
	117	if (!thread)
	118	error (_("Can't fetch registers from thread %s: No such thread"),
	119	target_pid_to_str (ptid));
	120
	121	if (regno < I386_NUM_GREGS \|\| regno == -1)
	122	{
	123	thread_state_t state;
	124
	125	/* This does the dirty work for us. */
	126	state = proc_get_state (thread, 0);
	127	if (!state)
	128	{
	129	warning (_("Couldn't fetch registers from %s"),
	130	proc_string (thread));
	131	return;
	132	}
	133
	134	if (regno == -1)
	135	{
	136	int i;
	137
	138	proc_debug (thread, "fetching all register");
	139
	140	for (i = 0; i < I386_NUM_GREGS; i++)
	141	regcache_raw_supply (regcache, i, REG_ADDR (state, i));
	142	thread->fetched_regs = ~0;
	143	}
	144	else
	145	{
	146	proc_debug (thread, "fetching register %s",
	147	gdbarch_register_name (regcache->arch (),
	148	regno));
	149
	150	regcache_raw_supply (regcache, regno,
	151	REG_ADDR (state, regno));
	152	thread->fetched_regs \|= (1 << regno);
	153	}
	154	}
	155
	156	if (regno >= I386_NUM_GREGS \|\| regno == -1)
	157	{
	158	proc_debug (thread, "fetching floating-point registers");
	159
	160	fetch_fpregs (regcache, thread);
	161	}
	162	}
	163	\f
	164
	165	/* Store the whole floating-point state into THREAD using information
	166	from the corresponding (pseudo) registers. */
	167	static void
	168	store_fpregs (const struct regcache regcache, struct proc thread, int regno)
	169	{
	170	mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
	171	struct i386_float_state state;
	172	kern_return_t err;
	173
	174	err = thread_get_state (thread->port, i386_FLOAT_STATE,
	175	(thread_state_t) &state, &count);
	176	if (err)
	177	{
	178	warning (_("Couldn't fetch floating-point state from %s"),
	179	proc_string (thread));
	180	return;
	181	}
	182
	183	/* FIXME: kettenis/2001-07-15: Is this right? Should we somehow
	184	take into account DEPRECATED_REGISTER_VALID like the old code did? */
	185	i387_collect_fsave (regcache, regno, state.hw_state);
	186
	187	err = thread_set_state (thread->port, i386_FLOAT_STATE,
	188	(thread_state_t) &state, i386_FLOAT_STATE_COUNT);
	189	if (err)
	190	{
	191	warning (_("Couldn't store floating-point state into %s"),
	192	proc_string (thread));
	193	return;
	194	}
	195	}
	196
	197	/* Store at least register REGNO, or all regs if REGNO == -1. */
	198	static void
	199	gnu_store_registers (struct target_ops *ops,
	200	struct regcache *regcache, int regno)
	201	{
	202	struct proc *thread;
	203	struct gdbarch *gdbarch = regcache->arch ();
	204	ptid_t ptid = regcache_get_ptid (regcache);
	205
	206	/* Make sure we know about new threads. */
	207	inf_update_procs (gnu_current_inf);
	208
	209	thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
	210	if (!thread)
	211	error (_("Couldn't store registers into thread %s: No such thread"),
	212	target_pid_to_str (ptid));
	213
	214	if (regno < I386_NUM_GREGS \|\| regno == -1)
	215	{
	216	thread_state_t state;
	217	thread_state_data_t old_state;
	218	int was_aborted = thread->aborted;
	219	int was_valid = thread->state_valid;
	220	int trace;
	221
	222	if (!was_aborted && was_valid)
	223	memcpy (&old_state, &thread->state, sizeof (old_state));
	224
	225	state = proc_get_state (thread, 1);
	226	if (!state)
	227	{
	228	warning (_("Couldn't store registers into %s"),
	229	proc_string (thread));
	230	return;
	231	}
	232
	233	/* Save the T bit. We might try to restore the %eflags register
	234	below, but changing the T bit would seriously confuse GDB. */
	235	trace = ((struct i386_thread_state *)state)->efl & 0x100;
	236
	237	if (!was_aborted && was_valid)
	238	/* See which registers have changed after aborting the thread. */
	239	{
	240	int check_regno;
	241
	242	for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
	243	if ((thread->fetched_regs & (1 << check_regno))
	244	&& memcpy (REG_ADDR (&old_state, check_regno),
	245	REG_ADDR (state, check_regno),
	246	register_size (gdbarch, check_regno)))
	247	/* Register CHECK_REGNO has changed! Ack! */
	248	{
	249	warning (_("Register %s changed after the thread was aborted"),
	250	gdbarch_register_name (gdbarch, check_regno));
	251	if (regno >= 0 && regno != check_regno)
	252	/* Update GDB's copy of the register. */
	253	regcache_raw_supply (regcache, check_regno,
	254	REG_ADDR (state, check_regno));
	255	else
	256	warning (_("... also writing this register! "
	257	"Suspicious..."));
	258	}
	259	}
	260
	261	if (regno == -1)
	262	{
	263	int i;
	264
	265	proc_debug (thread, "storing all registers");
	266
	267	for (i = 0; i < I386_NUM_GREGS; i++)
	268	if (REG_VALID == regcache_register_status (regcache, i))
	269	regcache_raw_collect (regcache, i, REG_ADDR (state, i));
	270	}
	271	else
	272	{
	273	proc_debug (thread, "storing register %s",
	274	gdbarch_register_name (gdbarch, regno));
	275
	276	gdb_assert (REG_VALID == regcache_register_status (regcache, regno));
	277	regcache_raw_collect (regcache, regno, REG_ADDR (state, regno));
	278	}
	279
	280	/* Restore the T bit. */
	281	((struct i386_thread_state *)state)->efl &= ~0x100;
	282	((struct i386_thread_state *)state)->efl \|= trace;
	283	}
	284
	285	if (regno >= I386_NUM_GREGS \|\| regno == -1)
	286	{
	287	proc_debug (thread, "storing floating-point registers");
	288
	289	store_fpregs (regcache, thread, regno);
	290	}
	291	}
	292
	293	\f
	294	/* Support for debug registers. */
	295
	296	#ifdef i386_DEBUG_STATE
	297	/* Get debug registers for thread THREAD. */
	298
	299	static void
	300	i386_gnu_dr_get (struct i386_debug_state regs, struct proc thread)
	301	{
	302	mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT;
	303	kern_return_t err;
	304
	305	err = thread_get_state (thread->port, i386_DEBUG_STATE,
	306	(thread_state_t) regs, &count);
	307	if (err != 0 \|\| count != i386_DEBUG_STATE_COUNT)
	308	warning (_("Couldn't fetch debug state from %s"),
	309	proc_string (thread));
	310	}
	311
	312	/* Set debug registers for thread THREAD. */
	313
	314	static void
	315	i386_gnu_dr_set (const struct i386_debug_state regs, struct proc thread)
	316	{
	317	kern_return_t err;
	318
	319	err = thread_set_state (thread->port, i386_DEBUG_STATE,
	320	(thread_state_t) regs, i386_DEBUG_STATE_COUNT);
	321	if (err != 0)
	322	warning (_("Couldn't store debug state into %s"),
	323	proc_string (thread));
	324	}
	325
	326	/* Set DR_CONTROL in THREAD. */
	327
	328	static void
	329	i386_gnu_dr_set_control_one (struct proc thread, void arg)
	330	{
	331	unsigned long control = (unsigned long ) arg;
	332	struct i386_debug_state regs;
	333
	334	i386_gnu_dr_get (&regs, thread);
	335	regs.dr[DR_CONTROL] = *control;
	336	i386_gnu_dr_set (&regs, thread);
	337	}
	338
	339	/* Set DR_CONTROL to CONTROL in all threads. */
	340
	341	static void
	342	i386_gnu_dr_set_control (unsigned long control)
	343	{
	344	inf_update_procs (gnu_current_inf);
	345	inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control);
	346	}
	347
	348	/* Parameters to set a debugging address. */
	349
	350	struct reg_addr
	351	{
	352	int regnum; /* Register number (zero based). */
	353	CORE_ADDR addr; /* Address. */
	354	};
	355
	356	/* Set address REGNUM (zero based) to ADDR in THREAD. */
	357
	358	static void
	359	i386_gnu_dr_set_addr_one (struct proc thread, void arg)
	360	{
	361	struct reg_addr reg_addr = (struct reg_addr ) arg;
	362	struct i386_debug_state regs;
	363
	364	i386_gnu_dr_get (&regs, thread);
	365	regs.dr[reg_addr->regnum] = reg_addr->addr;
	366	i386_gnu_dr_set (&regs, thread);
	367	}
	368
	369	/* Set address REGNUM (zero based) to ADDR in all threads. */
	370
	371	static void
	372	i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr)
	373	{
	374	struct reg_addr reg_addr;
	375
	376	gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
	377
	378	reg_addr.regnum = regnum;
	379	reg_addr.addr = addr;
	380
	381	inf_update_procs (gnu_current_inf);
	382	inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, &reg_addr);
	383	}
	384
	385	/* Get debug register REGNUM value from only the one LWP of PTID. */
	386
	387	static unsigned long
	388	i386_gnu_dr_get_reg (ptid_t ptid, int regnum)
	389	{
	390	struct i386_debug_state regs;
	391	struct proc *thread;
	392
	393	/* Make sure we know about new threads. */
	394	inf_update_procs (gnu_current_inf);
	395
	396	thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
	397	i386_gnu_dr_get (&regs, thread);
	398
	399	return regs.dr[regnum];
	400	}
	401
	402	/* Return the inferior's debug register REGNUM. */
	403
	404	static CORE_ADDR
	405	i386_gnu_dr_get_addr (int regnum)
	406	{
	407	gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
	408
	409	return i386_gnu_dr_get_reg (inferior_ptid, regnum);
	410	}
	411
	412	/* Get DR_STATUS from only the one thread of INFERIOR_PTID. */
	413
	414	static unsigned long
	415	i386_gnu_dr_get_status (void)
	416	{
	417	return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS);
	418	}
	419
	420	/* Return the inferior's DR7 debug control register. */
	421
	422	static unsigned long
	423	i386_gnu_dr_get_control (void)
	424	{
	425	return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL);
	426	}
	427	#endif /* i386_DEBUG_STATE */
	428
	429	void
	430	_initialize_i386gnu_nat (void)
	431	{
	432	#ifdef i386_DEBUG_STATE
	433	x86_dr_low.set_control = i386_gnu_dr_set_control;
	434	gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT);
	435	x86_dr_low.set_addr = i386_gnu_dr_set_addr;
	436	x86_dr_low.get_addr = i386_gnu_dr_get_addr;
	437	x86_dr_low.get_status = i386_gnu_dr_get_status;
	438	x86_dr_low.get_control = i386_gnu_dr_get_control;
	439	x86_set_debug_register_length (4);
	440	#endif /* i386_DEBUG_STATE */
	441
	442	/* Register the target. */
	443	add_inf_child_target (&the_i386_gnu_nat_target);
	444	}