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

/* Native-dependent code for modern i386 BSD's.

   Copyright (C) 2000-2020 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/>.  */

#include "defs.h"
#include "inferior.h"
#include "regcache.h"

#include <signal.h>
#include <sys/types.h>
#include <sys/ptrace.h>
#include <machine/reg.h>
#include <machine/frame.h>

#include "i386-tdep.h"
#include "i387-tdep.h"
#include "x86-bsd-nat.h"
#include "i386-bsd-nat.h"
#include "inf-ptrace.h"
\f

/* In older BSD versions we cannot get at some of the segment
   registers.  FreeBSD for example didn't support the %fs and %gs
   registers until the 3.0 release.  We have autoconf checks for their
   presence, and deal gracefully with their absence.  */

/* Offset in `struct reg' where MEMBER is stored.  */
#define REG_OFFSET(member) offsetof (struct reg, member)

/* At i386bsd_reg_offset[REGNUM] you'll find the offset in `struct
   reg' where the GDB register REGNUM is stored.  Unsupported
   registers are marked with `-1'.  */
static int i386bsd_r_reg_offset[] =
{
  REG_OFFSET (r_eax),
  REG_OFFSET (r_ecx),
  REG_OFFSET (r_edx),
  REG_OFFSET (r_ebx),
  REG_OFFSET (r_esp),
  REG_OFFSET (r_ebp),
  REG_OFFSET (r_esi),
  REG_OFFSET (r_edi),
  REG_OFFSET (r_eip),
  REG_OFFSET (r_eflags),
  REG_OFFSET (r_cs),
  REG_OFFSET (r_ss),
  REG_OFFSET (r_ds),
  REG_OFFSET (r_es),
#ifdef HAVE_STRUCT_REG_R_FS
  REG_OFFSET (r_fs),
#else
  -1,
#endif
#ifdef HAVE_STRUCT_REG_R_GS
  REG_OFFSET (r_gs)
#else
  -1
#endif
};

/* Macro to determine if a register is fetched with PT_GETREGS.  */
#define GETREGS_SUPPLIES(regnum) \
  ((0 <= (regnum) && (regnum) <= 15))

#ifdef HAVE_PT_GETXMMREGS
/* Set to 1 if the kernel supports PT_GETXMMREGS.  Initialized to -1
   so that we try PT_GETXMMREGS the first time around.  */
static int have_ptrace_xmmregs = -1;
#endif
\f

/* Supply the general-purpose registers in GREGS, to REGCACHE.  */

static void
i386bsd_supply_gregset (struct regcache *regcache, const void *gregs)
{
  const char *regs = (const char *) gregs;
  int regnum;

  for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
    {
      int offset = i386bsd_r_reg_offset[regnum];

      if (offset != -1)
	regcache->raw_supply (regnum, regs + offset);
    }
}

/* Collect register REGNUM from REGCACHE and store its contents in
   GREGS.  If REGNUM is -1, collect and store all appropriate
   registers.  */

static void
i386bsd_collect_gregset (const struct regcache *regcache,
			 void *gregs, int regnum)
{
  char *regs = (char *) gregs;
  int i;

  for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++)
    {
      if (regnum == -1 || regnum == i)
	{
	  int offset = i386bsd_r_reg_offset[i];

	  if (offset != -1)
	    regcache->raw_collect (i, regs + offset);
	}
    }
}

/* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
   for all registers (including the floating point registers).  */

void
i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
{
  pid_t pid = get_ptrace_pid (regcache->ptid ());

  if (regnum == -1 || GETREGS_SUPPLIES (regnum))
    {
      struct reg regs;

      if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
	perror_with_name (_("Couldn't get registers"));

      i386bsd_supply_gregset (regcache, &regs);
      if (regnum != -1)
	return;
    }

#ifdef PT_GETFSBASE
  if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
    {
      register_t base;

      if (ptrace (PT_GETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	perror_with_name (_("Couldn't get segment register fs_base"));

      regcache->raw_supply (I386_FSBASE_REGNUM, &base);
      if (regnum != -1)
	return;
    }
#endif
#ifdef PT_GETGSBASE
  if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
    {
      register_t base;

      if (ptrace (PT_GETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	perror_with_name (_("Couldn't get segment register gs_base"));

      regcache->raw_supply (I386_GSBASE_REGNUM, &base);
      if (regnum != -1)
	return;
    }
#endif

  if (regnum == -1 || regnum >= I386_ST0_REGNUM)
    {
      struct fpreg fpregs;
#ifdef HAVE_PT_GETXMMREGS
      char xmmregs[512];
#endif

#ifdef PT_GETXSTATE_INFO
      if (x86bsd_xsave_len != 0)
	{
	  void *xstateregs;

	  xstateregs = alloca (x86bsd_xsave_len);
	  if (ptrace (PT_GETXSTATE, pid,
		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
	    perror_with_name (_("Couldn't get extended state status"));

	  i387_supply_xsave (regcache, -1, xstateregs);
	  return;
	}
#endif
      
#ifdef HAVE_PT_GETXMMREGS
      if (have_ptrace_xmmregs != 0
	  && ptrace(PT_GETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
	{
	  have_ptrace_xmmregs = 1;
	  i387_supply_fxsave (regcache, -1, xmmregs);
	}
      else
	{
	  have_ptrace_xmmregs = 0;
#endif
          if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
	    perror_with_name (_("Couldn't get floating point status"));

	  i387_supply_fsave (regcache, -1, &fpregs);
#ifdef HAVE_PT_GETXMMREGS
	}
#endif
    }
}

/* Store register REGNUM back into the inferior.  If REGNUM is -1, do
   this for all registers (including the floating point registers).  */

void
i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
{
  pid_t pid = get_ptrace_pid (regcache->ptid ());

  if (regnum == -1 || GETREGS_SUPPLIES (regnum))
    {
      struct reg regs;

      if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't get registers"));

      i386bsd_collect_gregset (regcache, &regs, regnum);

      if (ptrace (PT_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
        perror_with_name (_("Couldn't write registers"));

      if (regnum != -1)
	return;
    }

#ifdef PT_SETFSBASE
  if (regnum == -1 || regnum == I386_FSBASE_REGNUM)
    {
      register_t base;

      regcache->raw_collect (I386_FSBASE_REGNUM, &base);

      if (ptrace (PT_SETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	perror_with_name (_("Couldn't write segment register fs_base"));
      if (regnum != -1)
	return;
    }
#endif
#ifdef PT_SETGSBASE
  if (regnum == -1 || regnum == I386_GSBASE_REGNUM)
    {
      register_t base;

      regcache->raw_collect (I386_GSBASE_REGNUM, &base);

      if (ptrace (PT_SETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	perror_with_name (_("Couldn't write segment register gs_base"));
      if (regnum != -1)
	return;
    }
#endif

  if (regnum == -1 || regnum >= I386_ST0_REGNUM)
    {
      struct fpreg fpregs;
#ifdef HAVE_PT_GETXMMREGS
      char xmmregs[512];
#endif

#ifdef PT_GETXSTATE_INFO
      if (x86bsd_xsave_len != 0)
	{
	  void *xstateregs;

	  xstateregs = alloca (x86bsd_xsave_len);
	  if (ptrace (PT_GETXSTATE, pid,
		      (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
	    perror_with_name (_("Couldn't get extended state status"));

	  i387_collect_xsave (regcache, -1, xstateregs, 0);

	  if (ptrace (PT_SETXSTATE, pid,
		      (PTRACE_TYPE_ARG3) xstateregs, x86bsd_xsave_len) == -1)
	    perror_with_name (_("Couldn't write extended state status"));
	  return;
	}
#endif

#ifdef HAVE_PT_GETXMMREGS
      if (have_ptrace_xmmregs != 0
	  && ptrace(PT_GETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
	{
	  have_ptrace_xmmregs = 1;

	  i387_collect_fxsave (regcache, regnum, xmmregs);

	  if (ptrace (PT_SETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
            perror_with_name (_("Couldn't write XMM registers"));
	}
      else
	{
	  have_ptrace_xmmregs = 0;
#endif
          if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
	    perror_with_name (_("Couldn't get floating point status"));

          i387_collect_fsave (regcache, regnum, &fpregs);

          if (ptrace (PT_SETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
	    perror_with_name (_("Couldn't write floating point status"));
#ifdef HAVE_PT_GETXMMREGS
        }
#endif
    }
}

void _initialize_i386bsd_nat ();
void
_initialize_i386bsd_nat ()
{
  int offset;

  /* To support the recognition of signal handlers, i386-bsd-tdep.c
     hardcodes some constants.  Inclusion of this file means that we
     are compiling a native debugger, which means that we can use the
     system header files and sysctl(3) to get at the relevant
     information.  */

#if defined (__FreeBSD_version) && __FreeBSD_version >= 400011
#define SC_REG_OFFSET i386fbsd4_sc_reg_offset
#elif defined (__FreeBSD_version) && __FreeBSD_version >= 300005
#define SC_REG_OFFSET i386fbsd_sc_reg_offset
#elif defined (NetBSD) || defined (__NetBSD_Version__)
#define SC_REG_OFFSET i386nbsd_sc_reg_offset
#elif defined (OpenBSD)
#define SC_REG_OFFSET i386obsd_sc_reg_offset
#endif

#ifdef SC_REG_OFFSET

  /* We only check the program counter, stack pointer and frame
     pointer since these members of `struct sigcontext' are essential
     for providing backtraces.  More checks could be added, but would
     involve adding configure checks for the appropriate structure
     members, since older BSD's don't provide all of them.  */

#define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
#define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
#define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]

  /* Override the default value for the offset of the program counter
     in the sigcontext structure.  */
  offset = offsetof (struct sigcontext, sc_pc);

  if (SC_PC_OFFSET != offset)
    {
      warning (_("\
offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
Please report this to <bug-gdb@gnu.org>."), 
	       offset, SC_PC_OFFSET);
    }

  SC_PC_OFFSET = offset;

  /* Likewise for the stack pointer.  */
  offset = offsetof (struct sigcontext, sc_sp);

  if (SC_SP_OFFSET != offset)
    {
      warning (_("\
offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
Please report this to <bug-gdb@gnu.org>."),
	       offset, SC_SP_OFFSET);
    }

  SC_SP_OFFSET = offset;

  /* And the frame pointer.  */
  offset = offsetof (struct sigcontext, sc_fp);

  if (SC_FP_OFFSET != offset)
    {
      warning (_("\
offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
Please report this to <bug-gdb@gnu.org>."),
	       offset, SC_FP_OFFSET);
    }

  SC_FP_OFFSET = offset;

#endif /* SC_REG_OFFSET */
}
Commit	Line	Data
e6031aeb	1	/* Native-dependent code for modern i386 BSD's.
3f63813d	2
b811d2c2	3	Copyright (C) 2000-2020 Free Software Foundation, Inc.
e6031aeb MK	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
e6031aeb MK	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
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
e6031aeb MK	19
	20	#include "defs.h"
	21	#include "inferior.h"
4e052eda	22	#include "regcache.h"
e6031aeb	23
b7247919	24	#include <signal.h>
e6031aeb MK	25	#include <sys/types.h>
	26	#include <sys/ptrace.h>
	27	#include <machine/reg.h>
	28	#include <machine/frame.h>
	29
57976e88	30	#include "i386-tdep.h"
1fc7d519	31	#include "i387-tdep.h"
03b62bbb SM	32	#include "x86-bsd-nat.h"
03b62bbb SM	33	#include "i386-bsd-nat.h"
9692934b	34	#include "inf-ptrace.h"
b051bfa4 MK	35	\f
b051bfa4 MK	36
e6031aeb MK	37	/* In older BSD versions we cannot get at some of the segment
	38	registers. FreeBSD for example didn't support the %fs and %gs
	39	registers until the 3.0 release. We have autoconf checks for their
	40	presence, and deal gracefully with their absence. */
	41
6cfb2041 MK	42	/* Offset in `struct reg' where MEMBER is stored. */
6cfb2041 MK	43	#define REG_OFFSET(member) offsetof (struct reg, member)
e6031aeb	44
6cfb2041 MK	45	/* At i386bsd_reg_offset[REGNUM] you'll find the offset in `struct
6cfb2041 MK	46	reg' where the GDB register REGNUM is stored. Unsupported
e6031aeb	47	registers are marked with `-1'. */
6cfb2041	48	static int i386bsd_r_reg_offset[] =
e6031aeb MK	49	{
	50	REG_OFFSET (r_eax),
	51	REG_OFFSET (r_ecx),
	52	REG_OFFSET (r_edx),
2c48bda3	53	REG_OFFSET (r_ebx),
e6031aeb MK	54	REG_OFFSET (r_esp),
	55	REG_OFFSET (r_ebp),
	56	REG_OFFSET (r_esi),
	57	REG_OFFSET (r_edi),
	58	REG_OFFSET (r_eip),
	59	REG_OFFSET (r_eflags),
	60	REG_OFFSET (r_cs),
	61	REG_OFFSET (r_ss),
	62	REG_OFFSET (r_ds),
	63	REG_OFFSET (r_es),
422ea4b8	64	#ifdef HAVE_STRUCT_REG_R_FS
e6031aeb MK	65	REG_OFFSET (r_fs),
	66	#else
	67	-1,
	68	#endif
422ea4b8	69	#ifdef HAVE_STRUCT_REG_R_GS
e6031aeb MK	70	REG_OFFSET (r_gs)
	71	#else
	72	-1
	73	#endif
	74	};
	75
7e89e357	76	/* Macro to determine if a register is fetched with PT_GETREGS. */
283accbc MK	77	#define GETREGS_SUPPLIES(regnum) \
283accbc MK	78	((0 <= (regnum) && (regnum) <= 15))
7e89e357 JT	79
	80	#ifdef HAVE_PT_GETXMMREGS
	81	/* Set to 1 if the kernel supports PT_GETXMMREGS. Initialized to -1
	82	so that we try PT_GETXMMREGS the first time around. */
	83	static int have_ptrace_xmmregs = -1;
	84	#endif
e6031aeb MK	85	\f
e6031aeb MK	86
6cfb2041	87	/* Supply the general-purpose registers in GREGS, to REGCACHE. */
e6031aeb	88
1fc7d519	89	static void
6cfb2041	90	i386bsd_supply_gregset (struct regcache regcache, const void gregs)
e6031aeb	91	{
21002a63	92	const char regs = (const char ) gregs;
feae6502	93	int regnum;
e6031aeb	94
6cfb2041	95	for (regnum = 0; regnum < ARRAY_SIZE (i386bsd_r_reg_offset); regnum++)
e6031aeb	96	{
6cfb2041 MK	97	int offset = i386bsd_r_reg_offset[regnum];
	98
	99	if (offset != -1)
73e1c03f	100	regcache->raw_supply (regnum, regs + offset);
e6031aeb MK	101	}
	102	}
	103
6cfb2041 MK	104	/* Collect register REGNUM from REGCACHE and store its contents in
	105	GREGS. If REGNUM is -1, collect and store all appropriate
	106	registers. */
e6031aeb	107
1fc7d519	108	static void
6cfb2041 MK	109	i386bsd_collect_gregset (const struct regcache *regcache,
6cfb2041 MK	110	void *gregs, int regnum)
e6031aeb	111	{
21002a63	112	char regs = (char ) gregs;
e6031aeb MK	113	int i;
e6031aeb MK	114
6cfb2041 MK	115	for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++)
	116	{
	117	if (regnum == -1 \|\| regnum == i)
	118	{
	119	int offset = i386bsd_r_reg_offset[i];
e6031aeb	120
6cfb2041	121	if (offset != -1)
34a79281	122	regcache->raw_collect (i, regs + offset);
6cfb2041 MK	123	}
	124	}
	125	}
e6031aeb	126
283accbc	127	/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
e6031aeb MK	128	for all registers (including the floating point registers). */
e6031aeb MK	129
f6ac5f3d PA	130	void
f6ac5f3d PA	131	i386bsd_fetch_inferior_registers (struct regcache *regcache, int regnum)
e6031aeb	132	{
222312d3	133	pid_t pid = get_ptrace_pid (regcache->ptid ());
aac12e24	134
283accbc	135	if (regnum == -1 \|\| GETREGS_SUPPLIES (regnum))
7e89e357	136	{
6cfb2041	137	struct reg regs;
7e89e357	138
aac12e24	139	if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5	140	perror_with_name (_("Couldn't get registers"));
e6031aeb	141
56be3814	142	i386bsd_supply_gregset (regcache, &regs);
283accbc	143	if (regnum != -1)
7e89e357 JT	144	return;
7e89e357 JT	145	}
e6031aeb	146
dd6876c9 JB	147	#ifdef PT_GETFSBASE
	148	if (regnum == -1 \|\| regnum == I386_FSBASE_REGNUM)
	149	{
	150	register_t base;
	151
	152	if (ptrace (PT_GETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	153	perror_with_name (_("Couldn't get segment register fs_base"));
	154
	155	regcache->raw_supply (I386_FSBASE_REGNUM, &base);
	156	if (regnum != -1)
	157	return;
	158	}
	159	#endif
	160	#ifdef PT_GETGSBASE
	161	if (regnum == -1 \|\| regnum == I386_GSBASE_REGNUM)
	162	{
	163	register_t base;
	164
	165	if (ptrace (PT_GETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	166	perror_with_name (_("Couldn't get segment register gs_base"));
	167
	168	regcache->raw_supply (I386_GSBASE_REGNUM, &base);
	169	if (regnum != -1)
	170	return;
	171	}
	172	#endif
	173
283accbc	174	if (regnum == -1 \|\| regnum >= I386_ST0_REGNUM)
e6031aeb	175	{
6cfb2041	176	struct fpreg fpregs;
7e89e357 JT	177	#ifdef HAVE_PT_GETXMMREGS
7e89e357 JT	178	char xmmregs[512];
97de3545 JB	179	#endif
	180
	181	#ifdef PT_GETXSTATE_INFO
a3405d12	182	if (x86bsd_xsave_len != 0)
97de3545	183	{
21002a63	184	void *xstateregs;
97de3545	185
a3405d12	186	xstateregs = alloca (x86bsd_xsave_len);
aac12e24	187	if (ptrace (PT_GETXSTATE, pid,
97de3545 JB	188	(PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
97de3545 JB	189	perror_with_name (_("Couldn't get extended state status"));
7e89e357	190
97de3545 JB	191	i387_supply_xsave (regcache, -1, xstateregs);
	192	return;
	193	}
	194	#endif
	195
	196	#ifdef HAVE_PT_GETXMMREGS
a144416f	197	if (have_ptrace_xmmregs != 0
aac12e24	198	&& ptrace(PT_GETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
7e89e357 JT	199	{
7e89e357 JT	200	have_ptrace_xmmregs = 1;
56be3814	201	i387_supply_fxsave (regcache, -1, xmmregs);
7e89e357 JT	202	}
	203	else
	204	{
97de3545 JB	205	have_ptrace_xmmregs = 0;
97de3545 JB	206	#endif
aac12e24	207	if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5	208	perror_with_name (_("Couldn't get floating point status"));
e6031aeb	209
56be3814	210	i387_supply_fsave (regcache, -1, &fpregs);
97de3545	211	#ifdef HAVE_PT_GETXMMREGS
7e89e357	212	}
7e89e357	213	#endif
e6031aeb	214	}
b051bfa4	215	}
e6031aeb	216
283accbc	217	/* Store register REGNUM back into the inferior. If REGNUM is -1, do
e6031aeb MK	218	this for all registers (including the floating point registers). */
e6031aeb MK	219
f6ac5f3d PA	220	void
f6ac5f3d PA	221	i386bsd_store_inferior_registers (struct regcache *regcache, int regnum)
e6031aeb	222	{
222312d3	223	pid_t pid = get_ptrace_pid (regcache->ptid ());
aac12e24	224
283accbc	225	if (regnum == -1 \|\| GETREGS_SUPPLIES (regnum))
7e89e357	226	{
6cfb2041	227	struct reg regs;
7e89e357	228
aac12e24	229	if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5	230	perror_with_name (_("Couldn't get registers"));
e6031aeb	231
56be3814	232	i386bsd_collect_gregset (regcache, &regs, regnum);
e6031aeb	233
aac12e24	234	if (ptrace (PT_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5	235	perror_with_name (_("Couldn't write registers"));
7e89e357	236
283accbc	237	if (regnum != -1)
7e89e357 JT	238	return;
7e89e357 JT	239	}
e6031aeb	240
dd6876c9 JB	241	#ifdef PT_SETFSBASE
	242	if (regnum == -1 \|\| regnum == I386_FSBASE_REGNUM)
	243	{
	244	register_t base;
	245
	246	regcache->raw_collect (I386_FSBASE_REGNUM, &base);
	247
	248	if (ptrace (PT_SETFSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	249	perror_with_name (_("Couldn't write segment register fs_base"));
	250	if (regnum != -1)
	251	return;
	252	}
	253	#endif
	254	#ifdef PT_SETGSBASE
	255	if (regnum == -1 \|\| regnum == I386_GSBASE_REGNUM)
	256	{
	257	register_t base;
	258
	259	regcache->raw_collect (I386_GSBASE_REGNUM, &base);
	260
	261	if (ptrace (PT_SETGSBASE, pid, (PTRACE_TYPE_ARG3) &base, 0) == -1)
	262	perror_with_name (_("Couldn't write segment register gs_base"));
	263	if (regnum != -1)
	264	return;
	265	}
	266	#endif
	267
283accbc	268	if (regnum == -1 \|\| regnum >= I386_ST0_REGNUM)
e6031aeb	269	{
6cfb2041	270	struct fpreg fpregs;
7e89e357 JT	271	#ifdef HAVE_PT_GETXMMREGS
7e89e357 JT	272	char xmmregs[512];
97de3545 JB	273	#endif
	274
	275	#ifdef PT_GETXSTATE_INFO
a3405d12	276	if (x86bsd_xsave_len != 0)
97de3545	277	{
21002a63	278	void *xstateregs;
97de3545	279
a3405d12	280	xstateregs = alloca (x86bsd_xsave_len);
aac12e24	281	if (ptrace (PT_GETXSTATE, pid,
97de3545 JB	282	(PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
97de3545 JB	283	perror_with_name (_("Couldn't get extended state status"));
e6031aeb	284
97de3545 JB	285	i387_collect_xsave (regcache, -1, xstateregs, 0);
97de3545 JB	286
aac12e24	287	if (ptrace (PT_SETXSTATE, pid,
a3405d12	288	(PTRACE_TYPE_ARG3) xstateregs, x86bsd_xsave_len) == -1)
97de3545 JB	289	perror_with_name (_("Couldn't write extended state status"));
	290	return;
	291	}
	292	#endif
	293
	294	#ifdef HAVE_PT_GETXMMREGS
a144416f	295	if (have_ptrace_xmmregs != 0
aac12e24	296	&& ptrace(PT_GETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
7e89e357 JT	297	{
	298	have_ptrace_xmmregs = 1;
	299
56be3814	300	i387_collect_fxsave (regcache, regnum, xmmregs);
e6031aeb	301
aac12e24	302	if (ptrace (PT_SETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == -1)
e2e0b3e5	303	perror_with_name (_("Couldn't write XMM registers"));
7e89e357 JT	304	}
	305	else
	306	{
	307	have_ptrace_xmmregs = 0;
	308	#endif
aac12e24	309	if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5	310	perror_with_name (_("Couldn't get floating point status"));
7e89e357	311
56be3814	312	i387_collect_fsave (regcache, regnum, &fpregs);
f5b1afdf	313
aac12e24	314	if (ptrace (PT_SETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5	315	perror_with_name (_("Couldn't write floating point status"));
7e89e357 JT	316	#ifdef HAVE_PT_GETXMMREGS
	317	}
	318	#endif
e6031aeb MK	319	}
e6031aeb MK	320	}
9692934b	321
6c265988	322	void _initialize_i386bsd_nat ();
b7247919	323	void
6c265988	324	_initialize_i386bsd_nat ()
b7247919	325	{
a3386186	326	int offset;
8201327c	327
03b62bbb	328	/* To support the recognition of signal handlers, i386-bsd-tdep.c
b7247919 MK	329	hardcodes some constants. Inclusion of this file means that we
	330	are compiling a native debugger, which means that we can use the
	331	system header files and sysctl(3) to get at the relevant
	332	information. */
	333
8201327c	334	#if defined (__FreeBSD_version) && __FreeBSD_version >= 400011
a3386186 MK	335	#define SC_REG_OFFSET i386fbsd4_sc_reg_offset
a3386186 MK	336	#elif defined (__FreeBSD_version) && __FreeBSD_version >= 300005
a3386186	337	#define SC_REG_OFFSET i386fbsd_sc_reg_offset
005328e3	338	#elif defined (NetBSD) \|\| defined (__NetBSD_Version__)
a3386186	339	#define SC_REG_OFFSET i386nbsd_sc_reg_offset
005328e3	340	#elif defined (OpenBSD)
a3386186	341	#define SC_REG_OFFSET i386obsd_sc_reg_offset
8201327c MK	342	#endif
8201327c MK	343
bbe06c74 MK	344	#ifdef SC_REG_OFFSET
bbe06c74 MK	345
a3386186 MK	346	/* We only check the program counter, stack pointer and frame
	347	pointer since these members of `struct sigcontext' are essential
	348	for providing backtraces. More checks could be added, but would
	349	involve adding configure checks for the appropriate structure
	350	members, since older BSD's don't provide all of them. */
	351
	352	#define SC_PC_OFFSET SC_REG_OFFSET[I386_EIP_REGNUM]
	353	#define SC_SP_OFFSET SC_REG_OFFSET[I386_ESP_REGNUM]
	354	#define SC_FP_OFFSET SC_REG_OFFSET[I386_EBP_REGNUM]
	355
b7247919 MK	356	/* Override the default value for the offset of the program counter
b7247919 MK	357	in the sigcontext structure. */
a3386186	358	offset = offsetof (struct sigcontext, sc_pc);
8201327c	359
a3386186	360	if (SC_PC_OFFSET != offset)
8201327c	361	{
8a3fe4f8	362	warning (_("\
8201327c	363	offsetof (struct sigcontext, sc_pc) yields %d instead of %d.\n\
8a3fe4f8	364	Please report this to <bug-gdb@gnu.org>."),
a3386186	365	offset, SC_PC_OFFSET);
8201327c MK	366	}
8201327c MK	367
a3386186	368	SC_PC_OFFSET = offset;
6bff26de MK	369
6bff26de MK	370	/* Likewise for the stack pointer. */
a3386186	371	offset = offsetof (struct sigcontext, sc_sp);
6bff26de	372
a3386186	373	if (SC_SP_OFFSET != offset)
6bff26de	374	{
8a3fe4f8	375	warning (_("\
6bff26de	376	offsetof (struct sigcontext, sc_sp) yields %d instead of %d.\n\
8a3fe4f8	377	Please report this to <bug-gdb@gnu.org>."),
a3386186 MK	378	offset, SC_SP_OFFSET);
	379	}
	380
	381	SC_SP_OFFSET = offset;
	382
	383	/* And the frame pointer. */
	384	offset = offsetof (struct sigcontext, sc_fp);
	385
	386	if (SC_FP_OFFSET != offset)
	387	{
8a3fe4f8	388	warning (_("\
a3386186	389	offsetof (struct sigcontext, sc_fp) yields %d instead of %d.\n\
8a3fe4f8	390	Please report this to <bug-gdb@gnu.org>."),
a3386186	391	offset, SC_FP_OFFSET);
6bff26de MK	392	}
6bff26de MK	393
a3386186	394	SC_FP_OFFSET = offset;
bbe06c74 MK	395
bbe06c74 MK	396	#endif /* SC_REG_OFFSET */
b7247919	397	}