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

/* Native-dependent code for FreeBSD/amd64.

   Copyright (C) 2003, 2004, 2007, 2008, 2009 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 "target.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>

#include "fbsd-nat.h"
#include "amd64-tdep.h"
#include "amd64-nat.h"
\f

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

/* At amd64fbsd64_r_reg_offset[REGNUM] you'll find the offset in
   `struct reg' location where the GDB register REGNUM is stored.
   Unsupported registers are marked with `-1'.  */
static int amd64fbsd64_r_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

/* Support for debugging kernel virtual memory images.  */

#include <sys/types.h>
#include <machine/pcb.h>
#include <osreldate.h>

#include "bsd-kvm.h"

static int
amd64fbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
{
  /* The following is true for FreeBSD 5.2:

     The pcb contains %rip, %rbx, %rsp, %rbp, %r12, %r13, %r14, %r15,
     %ds, %es, %fs and %gs.  This accounts for all callee-saved
     registers specified by the psABI and then some.  Here %esp
     contains the stack pointer at the point just after the call to
     cpu_switch().  From this information we reconstruct the register
     state as it would like when we just returned from cpu_switch().  */

  /* The stack pointer shouldn't be zero.  */
  if (pcb->pcb_rsp == 0)
    return 0;

  pcb->pcb_rsp += 8;
  regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &pcb->pcb_rip);
  regcache_raw_supply (regcache, AMD64_RBX_REGNUM, &pcb->pcb_rbx);
  regcache_raw_supply (regcache, AMD64_RSP_REGNUM, &pcb->pcb_rsp);
  regcache_raw_supply (regcache, AMD64_RBP_REGNUM, &pcb->pcb_rbp);
  regcache_raw_supply (regcache, 12, &pcb->pcb_r12);
  regcache_raw_supply (regcache, 13, &pcb->pcb_r13);
  regcache_raw_supply (regcache, 14, &pcb->pcb_r14);
  regcache_raw_supply (regcache, 15, &pcb->pcb_r15);
#if (__FreeBSD_version <  800075)
  regcache_raw_supply (regcache, AMD64_DS_REGNUM, &pcb->pcb_ds);
  regcache_raw_supply (regcache, AMD64_ES_REGNUM, &pcb->pcb_es);
  regcache_raw_supply (regcache, AMD64_FS_REGNUM, &pcb->pcb_fs);
  regcache_raw_supply (regcache, AMD64_GS_REGNUM, &pcb->pcb_gs);
#endif

  return 1;
}
\f

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

void
_initialize_amd64fbsd_nat (void)
{
  struct target_ops *t;
  int offset;

  amd64_native_gregset32_reg_offset = amd64fbsd32_r_reg_offset;
  amd64_native_gregset64_reg_offset = amd64fbsd64_r_reg_offset;

  /* Add some extra features to the common *BSD/i386 target.  */
  t = amd64bsd_target ();
  t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
  t->to_find_memory_regions = fbsd_find_memory_regions;
  t->to_make_corefile_notes = fbsd_make_corefile_notes;
  add_target (t);

  /* Support debugging kernel virtual memory images.  */
  bsd_kvm_add_target (amd64fbsd_supply_pcb);

  /* 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[AMD64_RIP_REGNUM]
#define SC_RSP_OFFSET SC_REG_OFFSET[AMD64_RSP_REGNUM]
#define SC_RBP_OFFSET SC_REG_OFFSET[AMD64_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_addr = ps_strings - 32;
	amd64fbsd_sigtramp_end_addr = ps_strings;
      }
  }
}
Commit	Line	Data
	1	/* Native-dependent code for FreeBSD/amd64.
	2
	3	Copyright (C) 2003, 2004, 2007, 2008, 2009 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	#include "defs.h"
	21	#include "inferior.h"
	22	#include "regcache.h"
	23	#include "target.h"
	24
	25	#include "gdb_assert.h"
	26	#include <signal.h>
	27	#include <stddef.h>
	28	#include <sys/types.h>
	29	#include <sys/ptrace.h>
	30	#include <sys/sysctl.h>
	31	#include <machine/reg.h>
	32
	33	#include "fbsd-nat.h"
	34	#include "amd64-tdep.h"
	35	#include "amd64-nat.h"
	36	\f
	37
	38	/* Offset in `struct reg' where MEMBER is stored. */
	39	#define REG_OFFSET(member) offsetof (struct reg, member)
	40
	41	/* At amd64fbsd64_r_reg_offset[REGNUM] you'll find the offset in
	42	`struct reg' location where the GDB register REGNUM is stored.
	43	Unsupported registers are marked with `-1'. */
	44	static int amd64fbsd64_r_reg_offset[] =
	45	{
	46	REG_OFFSET (r_rax),
	47	REG_OFFSET (r_rbx),
	48	REG_OFFSET (r_rcx),
	49	REG_OFFSET (r_rdx),
	50	REG_OFFSET (r_rsi),
	51	REG_OFFSET (r_rdi),
	52	REG_OFFSET (r_rbp),
	53	REG_OFFSET (r_rsp),
	54	REG_OFFSET (r_r8),
	55	REG_OFFSET (r_r9),
	56	REG_OFFSET (r_r10),
	57	REG_OFFSET (r_r11),
	58	REG_OFFSET (r_r12),
	59	REG_OFFSET (r_r13),
	60	REG_OFFSET (r_r14),
	61	REG_OFFSET (r_r15),
	62	REG_OFFSET (r_rip),
	63	REG_OFFSET (r_rflags),
	64	REG_OFFSET (r_cs),
	65	REG_OFFSET (r_ss),
	66	-1,
	67	-1,
	68	-1,
	69	-1
	70	};
	71	\f
	72
	73	/* Mapping between the general-purpose registers in FreeBSD/amd64
	74	`struct reg' format and GDB's register cache layout for
	75	FreeBSD/i386.
	76
	77	Note that most FreeBSD/amd64 registers are 64-bit, while the
	78	FreeBSD/i386 registers are all 32-bit, but since we're
	79	little-endian we get away with that. */
	80
	81	/* From <machine/reg.h>. */
	82	static int amd64fbsd32_r_reg_offset[I386_NUM_GREGS] =
	83	{
	84	14 * 8, 13 * 8, /* %eax, %ecx */
	85	12 * 8, 11 * 8, /* %edx, %ebx */
	86	20 * 8, 10 * 8, /* %esp, %ebp */
	87	9 * 8, 8 * 8, /* %esi, %edi */
	88	17 * 8, 19 * 8, /* %eip, %eflags */
	89	18 * 8, 21 * 8, /* %cs, %ss */
	90	-1, -1, -1, -1 /* %ds, %es, %fs, %gs */
	91	};
	92	\f
	93
	94	/* Support for debugging kernel virtual memory images. */
	95
	96	#include <sys/types.h>
	97	#include <machine/pcb.h>
	98	#include <osreldate.h>
	99
	100	#include "bsd-kvm.h"
	101
	102	static int
	103	amd64fbsd_supply_pcb (struct regcache regcache, struct pcb pcb)
	104	{
	105	/* The following is true for FreeBSD 5.2:
	106
	107	The pcb contains %rip, %rbx, %rsp, %rbp, %r12, %r13, %r14, %r15,
	108	%ds, %es, %fs and %gs. This accounts for all callee-saved
	109	registers specified by the psABI and then some. Here %esp
	110	contains the stack pointer at the point just after the call to
	111	cpu_switch(). From this information we reconstruct the register
	112	state as it would like when we just returned from cpu_switch(). */
	113
	114	/* The stack pointer shouldn't be zero. */
	115	if (pcb->pcb_rsp == 0)
	116	return 0;
	117
	118	pcb->pcb_rsp += 8;
	119	regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &pcb->pcb_rip);
	120	regcache_raw_supply (regcache, AMD64_RBX_REGNUM, &pcb->pcb_rbx);
	121	regcache_raw_supply (regcache, AMD64_RSP_REGNUM, &pcb->pcb_rsp);
	122	regcache_raw_supply (regcache, AMD64_RBP_REGNUM, &pcb->pcb_rbp);
	123	regcache_raw_supply (regcache, 12, &pcb->pcb_r12);
	124	regcache_raw_supply (regcache, 13, &pcb->pcb_r13);
	125	regcache_raw_supply (regcache, 14, &pcb->pcb_r14);
	126	regcache_raw_supply (regcache, 15, &pcb->pcb_r15);
	127	#if (__FreeBSD_version < 800075)
	128	regcache_raw_supply (regcache, AMD64_DS_REGNUM, &pcb->pcb_ds);
	129	regcache_raw_supply (regcache, AMD64_ES_REGNUM, &pcb->pcb_es);
	130	regcache_raw_supply (regcache, AMD64_FS_REGNUM, &pcb->pcb_fs);
	131	regcache_raw_supply (regcache, AMD64_GS_REGNUM, &pcb->pcb_gs);
	132	#endif
	133
	134	return 1;
	135	}
	136	\f
	137
	138	/* Provide a prototype to silence -Wmissing-prototypes. */
	139	void _initialize_amd64fbsd_nat (void);
	140
	141	void
	142	_initialize_amd64fbsd_nat (void)
	143	{
	144	struct target_ops *t;
	145	int offset;
	146
	147	amd64_native_gregset32_reg_offset = amd64fbsd32_r_reg_offset;
	148	amd64_native_gregset64_reg_offset = amd64fbsd64_r_reg_offset;
	149
	150	/* Add some extra features to the common BSD/i386 target. /
	151	t = amd64bsd_target ();
	152	t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
	153	t->to_find_memory_regions = fbsd_find_memory_regions;
	154	t->to_make_corefile_notes = fbsd_make_corefile_notes;
	155	add_target (t);
	156
	157	/* Support debugging kernel virtual memory images. */
	158	bsd_kvm_add_target (amd64fbsd_supply_pcb);
	159
	160	/* To support the recognition of signal handlers, i386bsd-tdep.c
	161	hardcodes some constants. Inclusion of this file means that we
	162	are compiling a native debugger, which means that we can use the
	163	system header files and sysctl(3) to get at the relevant
	164	information. */
	165
	166	#define SC_REG_OFFSET amd64fbsd_sc_reg_offset
	167
	168	/* We only check the program counter, stack pointer and frame
	169	pointer since these members of `struct sigcontext' are essential
	170	for providing backtraces. */
	171
	172	#define SC_RIP_OFFSET SC_REG_OFFSET[AMD64_RIP_REGNUM]
	173	#define SC_RSP_OFFSET SC_REG_OFFSET[AMD64_RSP_REGNUM]
	174	#define SC_RBP_OFFSET SC_REG_OFFSET[AMD64_RBP_REGNUM]
	175
	176	/* Override the default value for the offset of the program counter
	177	in the sigcontext structure. */
	178	offset = offsetof (struct sigcontext, sc_rip);
	179
	180	if (SC_RIP_OFFSET != offset)
	181	{
	182	warning (_("\
	183	offsetof (struct sigcontext, sc_rip) yields %d instead of %d.\n\
	184	Please report this to <bug-gdb@gnu.org>."),
	185	offset, SC_RIP_OFFSET);
	186	}
	187
	188	SC_RIP_OFFSET = offset;
	189
	190	/* Likewise for the stack pointer. */
	191	offset = offsetof (struct sigcontext, sc_rsp);
	192
	193	if (SC_RSP_OFFSET != offset)
	194	{
	195	warning (_("\
	196	offsetof (struct sigcontext, sc_rsp) yields %d instead of %d.\n\
	197	Please report this to <bug-gdb@gnu.org>."),
	198	offset, SC_RSP_OFFSET);
	199	}
	200
	201	SC_RSP_OFFSET = offset;
	202
	203	/* And the frame pointer. */
	204	offset = offsetof (struct sigcontext, sc_rbp);
	205
	206	if (SC_RBP_OFFSET != offset)
	207	{
	208	warning (_("\
	209	offsetof (struct sigcontext, sc_rbp) yields %d instead of %d.\n\
	210	Please report this to <bug-gdb@gnu.org>."),
	211	offset, SC_RBP_OFFSET);
	212	}
	213
	214	SC_RBP_OFFSET = offset;
	215
	216	/* FreeBSD provides a kern.ps_strings sysctl that we can use to
	217	locate the sigtramp. That way we can still recognize a sigtramp
	218	if its location is changed in a new kernel. Of course this is
	219	still based on the assumption that the sigtramp is placed
	220	directly under the location where the program arguments and
	221	environment can be found. */
	222	{
	223	int mib[2];
	224	long ps_strings;
	225	size_t len;
	226
	227	mib[0] = CTL_KERN;
	228	mib[1] = KERN_PS_STRINGS;
	229	len = sizeof (ps_strings);
	230	if (sysctl (mib, 2, &ps_strings, &len, NULL, 0) == 0)
	231	{
	232	amd64fbsd_sigtramp_start_addr = ps_strings - 32;
	233	amd64fbsd_sigtramp_end_addr = ps_strings;
	234	}
	235	}
	236	}