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

/* Target-dependent code for OpenBSD/sparc64.

   Copyright (C) 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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, 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 "obsd-tdep.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.  */

/* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
   in virtual memory.  The randomness makes it somewhat tricky to
   detect it, but fortunately we can rely on the fact that the start
   of the sigtramp routine is page-aligned.  We recognize the
   trampoline by looking for the code that invokes the sigreturn
   system call.  The offset where we can find that code varies from
   release to release.

   By the way, the mapping mentioned above is read-only, so you cannot
   place a breakpoint in the signal trampoline.  */

/* Default page size.  */
static const int sparc64obsd_page_size = 8192;

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