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

/* Target-dependent code for OpenBSD/sparc64.

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

#include "gdb_assert.h"

#include "sparc64-tdep.h"
#include "nbsd-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);
      cache->base = addr;
    }

  /* We find the appropriate instance of `struct sigcontext' at a
     fixed offset in the signal frame.  */
  addr = cache->base + BIAS + 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, void *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);

  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, nbsd_lp64_solib_svr4_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.
	2
	3	Copyright 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 "frame.h"
	24	#include "frame-unwind.h"
	25	#include "osabi.h"
	26	#include "regset.h"
	27	#include "symtab.h"
	28	#include "solib-svr4.h"
	29	#include "trad-frame.h"
	30
	31	#include "gdb_assert.h"
	32
	33	#include "sparc64-tdep.h"
	34	#include "nbsd-tdep.h"
	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);
	136	cache->base = addr;
	137	}
	138
	139	/* We find the appropriate instance of `struct sigcontext' at a
	140	fixed offset in the signal frame. */
	141	addr = cache->base + BIAS + 128 + 16;
	142	cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame);
	143
	144	return cache;
	145	}
	146
	147	static void
	148	sparc64obsd_frame_this_id (struct frame_info next_frame, void *this_cache,
	149	struct frame_id *this_id)
	150	{
	151	struct sparc_frame_cache *cache =
	152	sparc64obsd_frame_cache (next_frame, this_cache);
	153
	154	(*this_id) = frame_id_build (cache->base, cache->pc);
	155	}
	156
	157	static void
	158	sparc64obsd_frame_prev_register (struct frame_info *next_frame,
	159	void **this_cache,
	160	int regnum, int *optimizedp,
	161	enum lval_type lvalp, CORE_ADDR addrp,
	162	int realnump, void valuep)
	163	{
	164	struct sparc_frame_cache *cache =
	165	sparc64obsd_frame_cache (next_frame, this_cache);
	166
1f67027d AC	167	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
1f67027d AC	168	optimizedp, lvalp, addrp, realnump, valuep);
1e067c66 MK	169	}
	170
	171	static const struct frame_unwind sparc64obsd_frame_unwind =
	172	{
	173	SIGTRAMP_FRAME,
	174	sparc64obsd_frame_this_id,
	175	sparc64obsd_frame_prev_register
	176	};
	177
	178	static const struct frame_unwind *
	179	sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
	180	{
	181	CORE_ADDR pc = frame_pc_unwind (next_frame);
	182	char *name;
	183
	184	find_pc_partial_function (pc, &name, NULL, NULL);
	185	if (sparc64obsd_pc_in_sigtramp (pc, name))
	186	return &sparc64obsd_frame_unwind;
	187
	188	return NULL;
	189	}
	190	\f
	191
	192	static void
	193	sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	194	{
	195	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	196
9ea75c57	197	tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
1e067c66 MK	198	tdep->sizeof_gregset = 832;
1e067c66 MK	199
1e067c66 MK	200	frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer);
	201
	202	sparc64_init_abi (info, gdbarch);
	203
	204	set_solib_svr4_fetch_link_map_offsets
	205	(gdbarch, nbsd_lp64_solib_svr4_fetch_link_map_offsets);
	206	}
	207
	208	\f
	209	/* Provide a prototype to silence -Wmissing-prototypes. */
	210	void _initialize_sparc64obsd_tdep (void);
	211
	212	void
	213	_initialize_sparc64obsd_tdep (void)
	214	{
	215	gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
	216	GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
	217	}