[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>

#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 "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);
  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);

  return 1;
}
\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 = amd64fbsd64_r_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[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;
      }
  }

  /* Support debugging kernel virtual memory images.  */
  bsd_kvm_add_target (amd64fbsd_supply_pcb);
}
Commit	Line	Data
68cc0bfb	1	/* Native-dependent code for FreeBSD/amd64.
2a6d284d	2
af233647	3	Copyright 2003, 2004 Free Software Foundation, Inc.
68cc0bfb 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
	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
85be1ca6	34	#include "amd64-tdep.h"
2a6d284d	35	#include "amd64-nat.h"
68cc0bfb MK	36	\f
68cc0bfb MK	37
cb461069 MK	38	/* Offset in `struct reg' where MEMBER is stored. */
cb461069 MK	39	#define REG_OFFSET(member) offsetof (struct reg, member)
68cc0bfb	40
cb461069 MK	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[] =
68cc0bfb MK	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),
af233647 MK	64	REG_OFFSET (r_cs),
af233647 MK	65	REG_OFFSET (r_ss),
68cc0bfb MK	66	-1,
	67	-1,
	68	-1,
	69	-1
	70	};
2a6d284d MK	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.
68cc0bfb	76
2a6d284d MK	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. */
68cc0bfb	80
2a6d284d MK	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	};
68cc0bfb MK	92	\f
68cc0bfb MK	93
315c4276 MK	94	/* Support for debugging kernel virtual memory images. */
	95
	96	#include <sys/types.h>
	97	#include <machine/pcb.h>
	98
	99	#include "bsd-kvm.h"
	100
	101	static int
	102	amd64fbsd_supply_pcb (struct regcache regcache, struct pcb pcb)
	103	{
	104	/* The following is true for FreeBSD 5.2:
	105
	106	The pcb contains %rip, %rbx, %rsp, %rbp, %r12, %r13, %r14, %r15,
	107	%ds, %es, %fs and %gs. This accounts for all callee-saved
	108	registers specified by the psABI and then some. Here %esp
	109	contains the stack pointer at the point just after the call to
	110	cpu_switch(). From this information we reconstruct the register
	111	state as it would like when we just returned from cpu_switch(). */
	112
	113	/* The stack pointer shouldn't be zero. */
	114	if (pcb->pcb_rsp == 0)
	115	return 0;
	116
	117	pcb->pcb_rsp += 8;
	118	regcache_raw_supply (regcache, AMD64_RIP_REGNUM, &pcb->pcb_rip);
	119	regcache_raw_supply (regcache, AMD64_RBX_REGNUM, &pcb->pcb_rbx);
	120	regcache_raw_supply (regcache, AMD64_RSP_REGNUM, &pcb->pcb_rsp);
	121	regcache_raw_supply (regcache, AMD64_RBP_REGNUM, &pcb->pcb_rbp);
	122	regcache_raw_supply (regcache, 12, &pcb->pcb_r12);
	123	regcache_raw_supply (regcache, 13, &pcb->pcb_r13);
	124	regcache_raw_supply (regcache, 14, &pcb->pcb_r14);
	125	regcache_raw_supply (regcache, 15, &pcb->pcb_r15);
	126	regcache_raw_supply (regcache, AMD64_DS_REGNUM, &pcb->pcb_ds);
	127	regcache_raw_supply (regcache, AMD64_ES_REGNUM, &pcb->pcb_es);
	128	regcache_raw_supply (regcache, AMD64_FS_REGNUM, &pcb->pcb_fs);
	129	regcache_raw_supply (regcache, AMD64_GS_REGNUM, &pcb->pcb_gs);
	130
	131	return 1;
	132	}
	133	\f
	134
68cc0bfb MK	135	/* Provide a prototype to silence -Wmissing-prototypes. */
	136	void _initialize_amd64fbsd_nat (void);
	137
	138	void
1c671366	139	_initialize_amd64fbsd_nat (void)
68cc0bfb MK	140	{
	141	int offset;
	142
2a6d284d	143	amd64_native_gregset32_reg_offset = amd64fbsd32_r_reg_offset;
cb461069	144	amd64_native_gregset64_reg_offset = amd64fbsd64_r_reg_offset;
2a6d284d	145
68cc0bfb MK	146	/* To support the recognition of signal handlers, i386bsd-tdep.c
	147	hardcodes some constants. Inclusion of this file means that we
	148	are compiling a native debugger, which means that we can use the
	149	system header files and sysctl(3) to get at the relevant
	150	information. */
	151
68cc0bfb MK	152	#define SC_REG_OFFSET amd64fbsd_sc_reg_offset
	153
	154	/* We only check the program counter, stack pointer and frame
	155	pointer since these members of `struct sigcontext' are essential
	156	for providing backtraces. */
	157
90f90721 MK	158	#define SC_RIP_OFFSET SC_REG_OFFSET[AMD64_RIP_REGNUM]
	159	#define SC_RSP_OFFSET SC_REG_OFFSET[AMD64_RSP_REGNUM]
	160	#define SC_RBP_OFFSET SC_REG_OFFSET[AMD64_RBP_REGNUM]
68cc0bfb MK	161
	162	/* Override the default value for the offset of the program counter
	163	in the sigcontext structure. */
	164	offset = offsetof (struct sigcontext, sc_rip);
	165
	166	if (SC_RIP_OFFSET != offset)
	167	{
	168	warning ("\
	169	offsetof (struct sigcontext, sc_rip) yields %d instead of %d.\n\
	170	Please report this to <bug-gdb@gnu.org>.",
	171	offset, SC_RIP_OFFSET);
	172	}
	173
	174	SC_RIP_OFFSET = offset;
	175
	176	/* Likewise for the stack pointer. */
	177	offset = offsetof (struct sigcontext, sc_rsp);
	178
	179	if (SC_RSP_OFFSET != offset)
	180	{
	181	warning ("\
	182	offsetof (struct sigcontext, sc_rsp) yields %d instead of %d.\n\
	183	Please report this to <bug-gdb@gnu.org>.",
	184	offset, SC_RSP_OFFSET);
	185	}
	186
	187	SC_RSP_OFFSET = offset;
	188
	189	/* And the frame pointer. */
	190	offset = offsetof (struct sigcontext, sc_rbp);
	191
	192	if (SC_RBP_OFFSET != offset)
	193	{
	194	warning ("\
	195	offsetof (struct sigcontext, sc_rbp) yields %d instead of %d.\n\
	196	Please report this to <bug-gdb@gnu.org>.",
	197	offset, SC_RBP_OFFSET);
	198	}
	199
	200	SC_RBP_OFFSET = offset;
	201
	202	/* FreeBSD provides a kern.ps_strings sysctl that we can use to
	203	locate the sigtramp. That way we can still recognize a sigtramp
	204	if its location is changed in a new kernel. Of course this is
	205	still based on the assumption that the sigtramp is placed
	206	directly under the location where the program arguments and
	207	environment can be found. */
	208	{
	209	int mib[2];
de5227fb	210	long ps_strings;
68cc0bfb MK	211	size_t len;
68cc0bfb MK	212
68cc0bfb MK	213	mib[0] = CTL_KERN;
	214	mib[1] = KERN_PS_STRINGS;
	215	len = sizeof (ps_strings);
	216	if (sysctl (mib, 2, &ps_strings, &len, NULL, 0) == 0)
	217	{
10fc94a4 MK	218	amd64fbsd_sigtramp_start_addr = ps_strings - 32;
10fc94a4 MK	219	amd64fbsd_sigtramp_end_addr = ps_strings;
68cc0bfb MK	220	}
68cc0bfb MK	221	}
315c4276 MK	222
	223	/* Support debugging kernel virtual memory images. */
	224	bsd_kvm_add_target (amd64fbsd_supply_pcb);
68cc0bfb	225	}