[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

static PTRACE_TYPE_RET
gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr,
	    PTRACE_TYPE_ARG4 data)
{
#ifdef __NetBSD__
  gdb_assert (data == 0);
  /* Support for NetBSD threads: unlike other ptrace implementations in this
     file, NetBSD requires that we pass both the pid and lwp.  */
  return ptrace (request, ptid.pid (), addr, ptid.lwp ());
#else
  pid_t pid = get_ptrace_pid (ptid);
  return ptrace (request, pid, addr, data);
#endif
}

/* 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)
{
  ptid_t ptid = regcache->ptid ();

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

      if (gdb_ptrace (PT_GETREGS, ptid, (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 (gdb_ptrace (PT_GETFSBASE, ptid, (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 (gdb_ptrace (PT_GETGSBASE, ptid, (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 (gdb_ptrace (PT_GETXSTATE, ptid,
			  (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
	  && gdb_ptrace(PT_GETXMMREGS, ptid,
			(PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
	{
	  have_ptrace_xmmregs = 1;
	  i387_supply_fxsave (regcache, -1, xmmregs);
	}
      else
	{
	  have_ptrace_xmmregs = 0;
#endif
          if (gdb_ptrace (PT_GETFPREGS, ptid,
			  (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)
{
  ptid_t ptid = regcache->ptid ();

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

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

      i386bsd_collect_gregset (regcache, &regs, regnum);

      if (gdb_ptrace (PT_SETREGS, ptid, (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 (gdb_ptrace (PT_SETFSBASE, ptid, (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 (gdb_ptrace (PT_SETGSBASE, ptid, (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 (gdb_ptrace (PT_GETXSTATE, ptid,
			  (PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
	    perror_with_name (_("Couldn't get extended state status"));

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

	  if (gdb_ptrace (PT_SETXSTATE, ptid, (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
	  && gdb_ptrace(PT_GETXMMREGS, ptid,
			(PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
	{
	  have_ptrace_xmmregs = 1;

	  i387_collect_fxsave (regcache, regnum, xmmregs);

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

          i387_collect_fsave (regcache, regnum, &fpregs);

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