[deliverable/binutils-gdb.git] / gdb / amd64fbsd-nat.c

/* Native-dependent code for FreeBSD/amd64.

   Copyright 2003, 2004 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

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

#include "gdb_assert.h"
#include <signal.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/ptrace.h>
#include <sys/sysctl.h>
#include <machine/reg.h>

#ifdef HAVE_SYS_PROCFS_H
#include <sys/procfs.h>
#endif

#ifndef HAVE_GREGSET_T
typedef struct reg gregset_t;
#endif

#ifndef HAVE_FPREGSET_T
typedef struct fpreg fpregset_t;
#endif

#include "gregset.h"
#include "x86-64-tdep.h"
#include "amd64-nat.h"
\f

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

/* At reg_offset[REGNUM] you'll find the offset to the gregset_t
   location where the GDB register REGNUM is stored.  Unsupported
   registers are marked with `-1'.  */
static int reg_offset[] =
{
  REG_OFFSET (r_rax),
  REG_OFFSET (r_rbx),
  REG_OFFSET (r_rcx),
  REG_OFFSET (r_rdx),
  REG_OFFSET (r_rsi),
  REG_OFFSET (r_rdi),
  REG_OFFSET (r_rbp),
  REG_OFFSET (r_rsp),
  REG_OFFSET (r_r8),
  REG_OFFSET (r_r9),
  REG_OFFSET (r_r10),
  REG_OFFSET (r_r11),
  REG_OFFSET (r_r12),
  REG_OFFSET (r_r13),
  REG_OFFSET (r_r14),
  REG_OFFSET (r_r15),
  REG_OFFSET (r_rip),
  REG_OFFSET (r_rflags),
  REG_OFFSET (r_cs),
  REG_OFFSET (r_ss),
  -1,
  -1,
  -1,
  -1
};
\f

/* Mapping between the general-purpose registers in FreeBSD/amd64
   `struct reg' format and GDB's register cache layout for
   FreeBSD/i386.

   Note that most FreeBSD/amd64 registers are 64-bit, while the
   FreeBSD/i386 registers are all 32-bit, but since we're
   little-endian we get away with that.  */

/* From <machine/reg.h>.  */
static int amd64fbsd32_r_reg_offset[I386_NUM_GREGS] =
{
  14 * 8, 13 * 8,		/* %eax, %ecx */
  12 * 8, 11 * 8,		/* %edx, %ebx */
  20 * 8, 10 * 8,		/* %esp, %ebp */
  9 * 8, 8 * 8,			/* %esi, %edi */
  17 * 8, 19 * 8,		/* %eip, %eflags */
  18 * 8, 21 * 8,		/* %cs, %ss */
  -1, -1, -1, -1		/* %ds, %es, %fs, %gs */
};
\f

/* Transfering the registers between GDB, inferiors and core files.  */

/* Fill GDB's register array with the general-purpose register values
   in *GREGSETP.  */

void
supply_gregset (gregset_t *gregsetp)
{
  amd64_supply_native_gregset (current_regcache, gregsetp, -1);
}

/* Fill register REGNUM (if it is a general-purpose register) in
   *GREGSETPS with the value in GDB's register array.  If REGNUM is -1,
   do this for all registers.  */

void
fill_gregset (gregset_t *gregsetp, int regnum)
{
  amd64_collect_native_gregset (current_regcache, gregsetp, regnum);
}

/* Fill GDB's register array with the floating-point register values
   in *FPREGSETP.  */

void
supply_fpregset (fpregset_t *fpregsetp)
{
  x86_64_supply_fxsave (current_regcache, -1, fpregsetp);
}

/* Fill register REGNUM (if it is a floating-point register) in
   *FPREGSETP with the value in GDB's register array.  If REGNUM is -1,
   do this for all registers.  */

void
fill_fpregset (fpregset_t *fpregsetp, int regnum)
{
  x86_64_fill_fxsave ((char *) fpregsetp, regnum);
}
\f

/* Provide a prototype to silence -Wmissing-prototypes.  */
void _initialize_amd64fbsd_nat (void);

void
_initialize_amd64fbsd_nat (void)
{
  int offset;

  amd64_native_gregset32_reg_offset = amd64fbsd32_r_reg_offset;
  amd64_native_gregset64_reg_offset = reg_offset;

  /* To support the recognition of signal handlers, i386bsd-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.  */

#define SC_REG_OFFSET amd64fbsd_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.  */

#define SC_RIP_OFFSET SC_REG_OFFSET[X86_64_RIP_REGNUM]
#define SC_RSP_OFFSET SC_REG_OFFSET[X86_64_RSP_REGNUM]
#define SC_RBP_OFFSET SC_REG_OFFSET[X86_64_RBP_REGNUM]

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

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

  SC_RIP_OFFSET = offset;

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

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

  SC_RSP_OFFSET = offset;

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

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

  SC_RBP_OFFSET = offset;

  /* FreeBSD provides a kern.ps_strings sysctl that we can use to
     locate the sigtramp.  That way we can still recognize a sigtramp
     if its location is changed in a new kernel.  Of course this is
     still based on the assumption that the sigtramp is placed
     directly under the location where the program arguments and
     environment can be found.  */
  {
    int mib[2];
    long ps_strings;
    size_t len;

    mib[0] = CTL_KERN;
    mib[1] = KERN_PS_STRINGS;
    len = sizeof (ps_strings);
    if (sysctl (mib, 2, &ps_strings, &len, NULL, 0) == 0)
      {
	amd64fbsd_sigtramp_start = ps_strings - 32;
	amd64fbsd_sigtramp_end = ps_strings;
      }
  }
}
Commit	Line	Data
	1	/* Native-dependent code for FreeBSD/amd64.
	2
	3	Copyright 2003, 2004 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 2 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, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
	22	#include "defs.h"
	23	#include "inferior.h"
	24	#include "regcache.h"
	25
	26	#include "gdb_assert.h"
	27	#include <signal.h>
	28	#include <stddef.h>
	29	#include <sys/types.h>
	30	#include <sys/ptrace.h>
	31	#include <sys/sysctl.h>
	32	#include <machine/reg.h>
	33
	34	#ifdef HAVE_SYS_PROCFS_H
	35	#include <sys/procfs.h>
	36	#endif
	37
	38	#ifndef HAVE_GREGSET_T
	39	typedef struct reg gregset_t;
	40	#endif
	41
	42	#ifndef HAVE_FPREGSET_T
	43	typedef struct fpreg fpregset_t;
	44	#endif
	45
	46	#include "gregset.h"
	47	#include "x86-64-tdep.h"
	48	#include "amd64-nat.h"
	49	\f
	50
	51	/* Offset to the gregset_t location where REG is stored. */
	52	#define REG_OFFSET(reg) offsetof (gregset_t, reg)
	53
	54	/* At reg_offset[REGNUM] you'll find the offset to the gregset_t
	55	location where the GDB register REGNUM is stored. Unsupported
	56	registers are marked with `-1'. */
	57	static int reg_offset[] =
	58	{
	59	REG_OFFSET (r_rax),
	60	REG_OFFSET (r_rbx),
	61	REG_OFFSET (r_rcx),
	62	REG_OFFSET (r_rdx),
	63	REG_OFFSET (r_rsi),
	64	REG_OFFSET (r_rdi),
	65	REG_OFFSET (r_rbp),
	66	REG_OFFSET (r_rsp),
	67	REG_OFFSET (r_r8),
	68	REG_OFFSET (r_r9),
	69	REG_OFFSET (r_r10),
	70	REG_OFFSET (r_r11),
	71	REG_OFFSET (r_r12),
	72	REG_OFFSET (r_r13),
	73	REG_OFFSET (r_r14),
	74	REG_OFFSET (r_r15),
	75	REG_OFFSET (r_rip),
	76	REG_OFFSET (r_rflags),
	77	REG_OFFSET (r_cs),
	78	REG_OFFSET (r_ss),
	79	-1,
	80	-1,
	81	-1,
	82	-1
	83	};
	84	\f
	85
	86	/* Mapping between the general-purpose registers in FreeBSD/amd64
	87	`struct reg' format and GDB's register cache layout for
	88	FreeBSD/i386.
	89
	90	Note that most FreeBSD/amd64 registers are 64-bit, while the
	91	FreeBSD/i386 registers are all 32-bit, but since we're
	92	little-endian we get away with that. */
	93
	94	/* From <machine/reg.h>. */
	95	static int amd64fbsd32_r_reg_offset[I386_NUM_GREGS] =
	96	{
	97	14 * 8, 13 * 8, /* %eax, %ecx */
	98	12 * 8, 11 * 8, /* %edx, %ebx */
	99	20 * 8, 10 * 8, /* %esp, %ebp */
	100	9 * 8, 8 * 8, /* %esi, %edi */
	101	17 * 8, 19 * 8, /* %eip, %eflags */
	102	18 * 8, 21 * 8, /* %cs, %ss */
	103	-1, -1, -1, -1 /* %ds, %es, %fs, %gs */
	104	};
	105	\f
	106
	107	/* Transfering the registers between GDB, inferiors and core files. */
	108
	109	/* Fill GDB's register array with the general-purpose register values
	110	in GREGSETP. /
	111
	112	void
	113	supply_gregset (gregset_t *gregsetp)
	114	{
	115	amd64_supply_native_gregset (current_regcache, gregsetp, -1);
	116	}
	117
	118	/* Fill register REGNUM (if it is a general-purpose register) in
	119	*GREGSETPS with the value in GDB's register array. If REGNUM is -1,
	120	do this for all registers. */
	121
	122	void
	123	fill_gregset (gregset_t *gregsetp, int regnum)
	124	{
	125	amd64_collect_native_gregset (current_regcache, gregsetp, regnum);
	126	}
	127
	128	/* Fill GDB's register array with the floating-point register values
	129	in FPREGSETP. /
	130
	131	void
	132	supply_fpregset (fpregset_t *fpregsetp)
	133	{
	134	x86_64_supply_fxsave (current_regcache, -1, fpregsetp);
	135	}
	136
	137	/* Fill register REGNUM (if it is a floating-point register) in
	138	*FPREGSETP with the value in GDB's register array. If REGNUM is -1,
	139	do this for all registers. */
	140
	141	void
	142	fill_fpregset (fpregset_t *fpregsetp, int regnum)
	143	{
	144	x86_64_fill_fxsave ((char *) fpregsetp, regnum);
	145	}
	146	\f
	147
	148	/* Provide a prototype to silence -Wmissing-prototypes. */
	149	void _initialize_amd64fbsd_nat (void);
	150
	151	void
	152	_initialize_amd64fbsd_nat (void)
	153	{
	154	int offset;
	155
	156	amd64_native_gregset32_reg_offset = amd64fbsd32_r_reg_offset;
	157	amd64_native_gregset64_reg_offset = reg_offset;
	158
	159	/* To support the recognition of signal handlers, i386bsd-tdep.c
	160	hardcodes some constants. Inclusion of this file means that we
	161	are compiling a native debugger, which means that we can use the
	162	system header files and sysctl(3) to get at the relevant
	163	information. */
	164
	165	#define SC_REG_OFFSET amd64fbsd_sc_reg_offset
	166
	167	/* We only check the program counter, stack pointer and frame
	168	pointer since these members of `struct sigcontext' are essential
	169	for providing backtraces. */
	170
	171	#define SC_RIP_OFFSET SC_REG_OFFSET[X86_64_RIP_REGNUM]
	172	#define SC_RSP_OFFSET SC_REG_OFFSET[X86_64_RSP_REGNUM]
	173	#define SC_RBP_OFFSET SC_REG_OFFSET[X86_64_RBP_REGNUM]
	174
	175	/* Override the default value for the offset of the program counter
	176	in the sigcontext structure. */
	177	offset = offsetof (struct sigcontext, sc_rip);
	178
	179	if (SC_RIP_OFFSET != offset)
	180	{
	181	warning ("\
	182	offsetof (struct sigcontext, sc_rip) yields %d instead of %d.\n\
	183	Please report this to <bug-gdb@gnu.org>.",
	184	offset, SC_RIP_OFFSET);
	185	}
	186
	187	SC_RIP_OFFSET = offset;
	188
	189	/* Likewise for the stack pointer. */
	190	offset = offsetof (struct sigcontext, sc_rsp);
	191
	192	if (SC_RSP_OFFSET != offset)
	193	{
	194	warning ("\
	195	offsetof (struct sigcontext, sc_rsp) yields %d instead of %d.\n\
	196	Please report this to <bug-gdb@gnu.org>.",
	197	offset, SC_RSP_OFFSET);
	198	}
	199
	200	SC_RSP_OFFSET = offset;
	201
	202	/* And the frame pointer. */
	203	offset = offsetof (struct sigcontext, sc_rbp);
	204
	205	if (SC_RBP_OFFSET != offset)
	206	{
	207	warning ("\
	208	offsetof (struct sigcontext, sc_rbp) yields %d instead of %d.\n\
	209	Please report this to <bug-gdb@gnu.org>.",
	210	offset, SC_RBP_OFFSET);
	211	}
	212
	213	SC_RBP_OFFSET = offset;
	214
	215	/* FreeBSD provides a kern.ps_strings sysctl that we can use to
	216	locate the sigtramp. That way we can still recognize a sigtramp
	217	if its location is changed in a new kernel. Of course this is
	218	still based on the assumption that the sigtramp is placed
	219	directly under the location where the program arguments and
	220	environment can be found. */
	221	{
	222	int mib[2];
	223	long ps_strings;
	224	size_t len;
	225
	226	mib[0] = CTL_KERN;
	227	mib[1] = KERN_PS_STRINGS;
	228	len = sizeof (ps_strings);
	229	if (sysctl (mib, 2, &ps_strings, &len, NULL, 0) == 0)
	230	{
	231	amd64fbsd_sigtramp_start = ps_strings - 32;
	232	amd64fbsd_sigtramp_end = ps_strings;
	233	}
	234	}
	235	}