[deliverable/binutils-gdb.git] / gdb / sparc64obsd-tdep.c

/* Target-dependent code for OpenBSD/sparc64.

   Copyright 2004, 2005 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 "frame.h"
#include "frame-unwind.h"
#include "osabi.h"
#include "regset.h"
#include "symtab.h"
#include "objfiles.h"
#include "solib-svr4.h"
#include "trad-frame.h"

#include "gdb_assert.h"

#include "sparc64-tdep.h"

/* OpenBSD uses the traditional NetBSD core file format, even for
   ports that use ELF.  The core files don't use multiple register
   sets.  Instead, the general-purpose and floating-point registers
   are lumped together in a single section.  Unlike on NetBSD, OpenBSD
   uses a different layout for its general-purpose registers than the
   layout used for ptrace(2).  */

/* From <machine/reg.h>.  */
const struct sparc_gregset sparc64obsd_core_gregset =
{
  0 * 8,			/* "tstate" */
  1 * 8,			/* %pc */
  2 * 8,			/* %npc */
  3 * 8,			/* %y */
  -1,				/* %fprs */
  -1,
  7 * 8,			/* %g1 */
  22 * 8,			/* %l0 */
  4				/* sizeof (%y) */
};

static void
sparc64obsd_supply_gregset (const struct regset *regset,
			    struct regcache *regcache,
			    int regnum, const void *gregs, size_t len)
{
  const char *regs = gregs;

  sparc64_supply_gregset (&sparc64obsd_core_gregset, regcache, regnum, regs);
  sparc64_supply_fpregset (regcache, regnum, regs + 288);
}
\f

/* Signal trampolines.  */

/* The OpenBSD kernel maps the signal trampoline at some random
   location in user space, which means that the traditional BSD way of
   detecting it won't work.

   The signal trampoline will be mapped at an address that is page
   aligned.  We recognize the signal trampoline by the looking for the
   sigreturn system call.  The offset where we can find the code that
   makes this system call varies from release to release.  For OpenBSD
   3.6 and later releases we can find the code at offset 0xec.  For
   OpenBSD 3.5 and earlier releases, we find it at offset 0xe8.  */

static const int sparc64obsd_page_size = 8192;
static const int sparc64obsd_sigreturn_offset[] = { 0xec, 0xe8, -1 };

static int
sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
  CORE_ADDR start_pc = (pc & ~(sparc64obsd_page_size - 1));
  unsigned long insn;
  const int *offset;

  if (name)
    return 0;

  for (offset = sparc64obsd_sigreturn_offset; *offset != -1; offset++)
    {
      /* Check for "restore %g0, SYS_sigreturn, %g1".  */
      insn = sparc_fetch_instruction (start_pc + *offset);
      if (insn != 0x83e82067)
	continue;

      /* Check for "t ST_SYSCALL".  */
      insn = sparc_fetch_instruction (start_pc + *offset + 8);
      if (insn != 0x91d02000)
	continue;

      return 1;
    }

  return 0;
}

static struct sparc_frame_cache *
sparc64obsd_frame_cache (struct frame_info *next_frame, void **this_cache)
{
  struct sparc_frame_cache *cache;
  CORE_ADDR addr;

  if (*this_cache)
    return *this_cache;

  cache = sparc_frame_cache (next_frame, this_cache);
  gdb_assert (cache == *this_cache);

  /* If we couldn't find the frame's function, we're probably dealing
     with an on-stack signal trampoline.  */
  if (cache->pc == 0)
    {
      cache->pc = frame_pc_unwind (next_frame);
      cache->pc &= ~(sparc64obsd_page_size - 1);

      /* Since we couldn't find the frame's function, the cache was
         initialized under the assumption that we're frameless.  */
      cache->frameless_p = 0;
      addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
      if (addr & 1)
	addr += BIAS;
      cache->base = addr;
    }

  /* We find the appropriate instance of `struct sigcontext' at a
     fixed offset in the signal frame.  */
  addr = cache->base + 128 + 16;
  cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame);

  return cache;
}

static void
sparc64obsd_frame_this_id (struct frame_info *next_frame, void **this_cache,
			   struct frame_id *this_id)
{
  struct sparc_frame_cache *cache =
    sparc64obsd_frame_cache (next_frame, this_cache);

  (*this_id) = frame_id_build (cache->base, cache->pc);
}

static void
sparc64obsd_frame_prev_register (struct frame_info *next_frame,
				 void **this_cache,
				 int regnum, int *optimizedp,
				 enum lval_type *lvalp, CORE_ADDR *addrp,
				 int *realnump, gdb_byte *valuep)
{
  struct sparc_frame_cache *cache =
    sparc64obsd_frame_cache (next_frame, this_cache);

  trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
				optimizedp, lvalp, addrp, realnump, valuep);
}

static const struct frame_unwind sparc64obsd_frame_unwind =
{
  SIGTRAMP_FRAME,
  sparc64obsd_frame_this_id,
  sparc64obsd_frame_prev_register
};

static const struct frame_unwind *
sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
{
  CORE_ADDR pc = frame_pc_unwind (next_frame);
  char *name;

  find_pc_partial_function (pc, &name, NULL, NULL);
  if (sparc64obsd_pc_in_sigtramp (pc, name))
    return &sparc64obsd_frame_unwind;

  return NULL;
}
\f

static void
sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
  tdep->sizeof_gregset = 832;

  frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer);

  sparc64_init_abi (info, gdbarch);

  /* OpenBSD/sparc64 has SVR4-style shared libraries.  */
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, svr4_lp64_fetch_link_map_offsets);
}
\f

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

void
_initialize_sparc64obsd_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
			  GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
}
Commit	Line	Data
1e067c66 MK	1	/* Target-dependent code for OpenBSD/sparc64.
1e067c66 MK	2
5b2d44a0	3	Copyright 2004, 2005 Free Software Foundation, Inc.
1e067c66 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 "frame.h"
	24	#include "frame-unwind.h"
	25	#include "osabi.h"
	26	#include "regset.h"
	27	#include "symtab.h"
3510d1f2	28	#include "objfiles.h"
1e067c66 MK	29	#include "solib-svr4.h"
	30	#include "trad-frame.h"
	31
	32	#include "gdb_assert.h"
	33
	34	#include "sparc64-tdep.h"
1e067c66 MK	35
	36	/* OpenBSD uses the traditional NetBSD core file format, even for
	37	ports that use ELF. The core files don't use multiple register
	38	sets. Instead, the general-purpose and floating-point registers
	39	are lumped together in a single section. Unlike on NetBSD, OpenBSD
	40	uses a different layout for its general-purpose registers than the
	41	layout used for ptrace(2). */
	42
	43	/* From <machine/reg.h>. */
	44	const struct sparc_gregset sparc64obsd_core_gregset =
	45	{
	46	0 * 8, /* "tstate" */
	47	1 * 8, /* %pc */
	48	2 * 8, /* %npc */
	49	3 * 8, /* %y */
	50	-1, /* %fprs */
	51	-1,
	52	7 * 8, /* %g1 */
	53	22 * 8, /* %l0 */
	54	4 /* sizeof (%y) */
	55	};
	56
	57	static void
	58	sparc64obsd_supply_gregset (const struct regset *regset,
	59	struct regcache *regcache,
	60	int regnum, const void *gregs, size_t len)
	61	{
	62	const char *regs = gregs;
	63
9ea75c57	64	sparc64_supply_gregset (&sparc64obsd_core_gregset, regcache, regnum, regs);
1e067c66 MK	65	sparc64_supply_fpregset (regcache, regnum, regs + 288);
	66	}
	67	\f
	68
	69	/* Signal trampolines. */
	70
	71	/* The OpenBSD kernel maps the signal trampoline at some random
	72	location in user space, which means that the traditional BSD way of
	73	detecting it won't work.
	74
	75	The signal trampoline will be mapped at an address that is page
	76	aligned. We recognize the signal trampoline by the looking for the
dc856692 MK	77	sigreturn system call. The offset where we can find the code that
	78	makes this system call varies from release to release. For OpenBSD
	79	3.6 and later releases we can find the code at offset 0xec. For
	80	OpenBSD 3.5 and earlier releases, we find it at offset 0xe8. */
1e067c66 MK	81
1e067c66 MK	82	static const int sparc64obsd_page_size = 8192;
dc856692	83	static const int sparc64obsd_sigreturn_offset[] = { 0xec, 0xe8, -1 };
1e067c66 MK	84
	85	static int
	86	sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
	87	{
	88	CORE_ADDR start_pc = (pc & ~(sparc64obsd_page_size - 1));
	89	unsigned long insn;
dc856692	90	const int *offset;
1e067c66 MK	91
	92	if (name)
	93	return 0;
	94
dc856692	95	for (offset = sparc64obsd_sigreturn_offset; *offset != -1; offset++)
24f033e8	96	{
dc856692 MK	97	/* Check for "restore %g0, SYS_sigreturn, %g1". */
	98	insn = sparc_fetch_instruction (start_pc + *offset);
	99	if (insn != 0x83e82067)
	100	continue;
1e067c66	101
dc856692 MK	102	/* Check for "t ST_SYSCALL". */
	103	insn = sparc_fetch_instruction (start_pc + *offset + 8);
	104	if (insn != 0x91d02000)
	105	continue;
	106
	107	return 1;
5a5effe1	108	}
1e067c66	109
dc856692	110	return 0;
1e067c66 MK	111	}
	112
	113	static struct sparc_frame_cache *
	114	sparc64obsd_frame_cache (struct frame_info next_frame, void *this_cache)
	115	{
	116	struct sparc_frame_cache *cache;
	117	CORE_ADDR addr;
	118
	119	if (*this_cache)
	120	return *this_cache;
	121
	122	cache = sparc_frame_cache (next_frame, this_cache);
	123	gdb_assert (cache == *this_cache);
	124
	125	/* If we couldn't find the frame's function, we're probably dealing
	126	with an on-stack signal trampoline. */
	127	if (cache->pc == 0)
	128	{
	129	cache->pc = frame_pc_unwind (next_frame);
	130	cache->pc &= ~(sparc64obsd_page_size - 1);
	131
	132	/* Since we couldn't find the frame's function, the cache was
	133	initialized under the assumption that we're frameless. */
	134	cache->frameless_p = 0;
	135	addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
5b2d44a0 MK	136	if (addr & 1)
5b2d44a0 MK	137	addr += BIAS;
1e067c66 MK	138	cache->base = addr;
	139	}
	140
	141	/* We find the appropriate instance of `struct sigcontext' at a
	142	fixed offset in the signal frame. */
5b2d44a0	143	addr = cache->base + 128 + 16;
1e067c66 MK	144	cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame);
	145
	146	return cache;
	147	}
	148
	149	static void
	150	sparc64obsd_frame_this_id (struct frame_info next_frame, void *this_cache,
	151	struct frame_id *this_id)
	152	{
	153	struct sparc_frame_cache *cache =
	154	sparc64obsd_frame_cache (next_frame, this_cache);
	155
	156	(*this_id) = frame_id_build (cache->base, cache->pc);
	157	}
	158
	159	static void
	160	sparc64obsd_frame_prev_register (struct frame_info *next_frame,
	161	void **this_cache,
	162	int regnum, int *optimizedp,
	163	enum lval_type lvalp, CORE_ADDR addrp,
47ef841b	164	int realnump, gdb_byte valuep)
1e067c66 MK	165	{
	166	struct sparc_frame_cache *cache =
	167	sparc64obsd_frame_cache (next_frame, this_cache);
	168
1f67027d AC	169	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
1f67027d AC	170	optimizedp, lvalp, addrp, realnump, valuep);
1e067c66 MK	171	}
	172
	173	static const struct frame_unwind sparc64obsd_frame_unwind =
	174	{
	175	SIGTRAMP_FRAME,
	176	sparc64obsd_frame_this_id,
	177	sparc64obsd_frame_prev_register
	178	};
	179
	180	static const struct frame_unwind *
	181	sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
	182	{
	183	CORE_ADDR pc = frame_pc_unwind (next_frame);
	184	char *name;
	185
	186	find_pc_partial_function (pc, &name, NULL, NULL);
	187	if (sparc64obsd_pc_in_sigtramp (pc, name))
	188	return &sparc64obsd_frame_unwind;
	189
	190	return NULL;
	191	}
	192	\f
	193
	194	static void
	195	sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	196	{
	197	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	198
9ea75c57	199	tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
1e067c66 MK	200	tdep->sizeof_gregset = 832;
1e067c66 MK	201
1e067c66 MK	202	frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer);
	203
	204	sparc64_init_abi (info, gdbarch);
	205
5b2d44a0	206	/* OpenBSD/sparc64 has SVR4-style shared libraries. */
3510d1f2	207	set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1e067c66	208	set_solib_svr4_fetch_link_map_offsets
3510d1f2	209	(gdbarch, svr4_lp64_fetch_link_map_offsets);
1e067c66	210	}
1e067c66	211	\f
5b2d44a0	212
1e067c66 MK	213	/* Provide a prototype to silence -Wmissing-prototypes. */
	214	void _initialize_sparc64obsd_tdep (void);
	215
	216	void
	217	_initialize_sparc64obsd_tdep (void)
	218	{
	219	gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
	220	GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
	221	}