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

/* Target-dependent code for OpenBSD/sparc64.

   Copyright (C) 2004, 2005, 2006, 2007 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 "gdbcore.h"
#include "osabi.h"
#include "regcache.h"
#include "regset.h"
#include "symtab.h"
#include "objfiles.h"
#include "trad-frame.h"

#include "gdb_assert.h"

#include "obsd-tdep.h"
#include "sparc64-tdep.h"
#include "solib-svr4.h"
#include "bsd-uthread.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
/* Kernel debugging support.  */

static struct sparc_frame_cache *
sparc64obsd_trapframe_cache (struct frame_info *next_frame, void **this_cache)
{
  struct sparc_frame_cache *cache;
  CORE_ADDR sp, trapframe_addr;
  int regnum;

  if (*this_cache)
    return *this_cache;

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

  sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
  trapframe_addr = sp + BIAS + 176;

  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);

  cache->saved_regs[SPARC64_STATE_REGNUM].addr = trapframe_addr;
  cache->saved_regs[SPARC64_PC_REGNUM].addr = trapframe_addr + 8;
  cache->saved_regs[SPARC64_NPC_REGNUM].addr = trapframe_addr + 16;

  for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
    cache->saved_regs[regnum].addr =
      trapframe_addr + 48 + (regnum - SPARC_G0_REGNUM) * 8;

  return cache;
}

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

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

static void
sparc64obsd_trapframe_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_trapframe_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_trapframe_unwind =
{
  NORMAL_FRAME,
  sparc64obsd_trapframe_this_id,
  sparc64obsd_trapframe_prev_register
};

static const struct frame_unwind *
sparc64obsd_trapframe_sniffer (struct frame_info *next_frame)
{
  CORE_ADDR pc;
  ULONGEST pstate;
  char *name;

  /* Check whether we are in privileged mode, and bail out if we're not.  */
  pstate = frame_unwind_register_unsigned (next_frame, SPARC64_PSTATE_REGNUM);
  if ((pstate & SPARC64_PSTATE_PRIV) == 0)
    return NULL;

  pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
  find_pc_partial_function (pc, &name, NULL, NULL);
  if (name && strcmp (name, "Lslowtrap_reenter") == 0)
    return &sparc64obsd_trapframe_unwind;

  return NULL;
}
\f

/* Threads support.  */

/* Offset wthin the thread structure where we can find %fp and %i7.  */
#define SPARC64OBSD_UTHREAD_FP_OFFSET	232
#define SPARC64OBSD_UTHREAD_PC_OFFSET	240

static void
sparc64obsd_supply_uthread (struct regcache *regcache,
			    int regnum, CORE_ADDR addr)
{
  CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
  gdb_byte buf[8];

  gdb_assert (regnum >= -1);

  fp = read_memory_unsigned_integer (fp_addr, 8);
  if (regnum == SPARC_SP_REGNUM || regnum == -1)
    {
      store_unsigned_integer (buf, 8, fp);
      regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);

      if (regnum == SPARC_SP_REGNUM)
	return;
    }

  if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM
      || regnum == -1)
    {
      CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;

      i7 = read_memory_unsigned_integer (i7_addr, 8);
      if (regnum == SPARC64_PC_REGNUM || regnum == -1)
	{
	  store_unsigned_integer (buf, 8, i7 + 8);
	  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
	}
      if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
	{
	  store_unsigned_integer (buf, 8, i7 + 12);
	  regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf);
	}

      if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
	return;
    }

  sparc_supply_rwindow (regcache, fp, regnum);
}

static void
sparc64obsd_collect_uthread(const struct regcache *regcache,
			    int regnum, CORE_ADDR addr)
{
  CORE_ADDR sp;
  gdb_byte buf[8];

  gdb_assert (regnum >= -1);

  if (regnum == SPARC_SP_REGNUM || regnum == -1)
    {
      CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;

      regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
      write_memory (fp_addr,buf, 8);
    }

  if (regnum == SPARC64_PC_REGNUM || regnum == -1)
    {
      CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;

      regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf);
      i7 = extract_unsigned_integer (buf, 8) - 8;
      write_memory_unsigned_integer (i7_addr, 8, i7);

      if (regnum == SPARC64_PC_REGNUM)
	return;
    }

  regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
  sp = extract_unsigned_integer (buf, 8);
  sparc_collect_rwindow (regcache, sp, regnum);
}
\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;

  /* Make sure we can single-step "new" syscalls.  */
  tdep->step_trap = sparcnbsd_step_trap;

  frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer);
  frame_unwind_append_sniffer (gdbarch, sparc64obsd_trapframe_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);

  /* OpenBSD provides a user-level threads implementation.  */
  bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread);
  bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread);
}
\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
6aba47ca	3	Copyright (C) 2004, 2005, 2006, 2007 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"
585e38ed	25	#include "gdbcore.h"
1e067c66	26	#include "osabi.h"
585e38ed	27	#include "regcache.h"
1e067c66 MK	28	#include "regset.h"
1e067c66 MK	29	#include "symtab.h"
3510d1f2	30	#include "objfiles.h"
1e067c66 MK	31	#include "trad-frame.h"
	32
	33	#include "gdb_assert.h"
	34
4807909c	35	#include "obsd-tdep.h"
1e067c66	36	#include "sparc64-tdep.h"
585e38ed MK	37	#include "solib-svr4.h"
585e38ed MK	38	#include "bsd-uthread.h"
1e067c66 MK	39
	40	/* OpenBSD uses the traditional NetBSD core file format, even for
	41	ports that use ELF. The core files don't use multiple register
	42	sets. Instead, the general-purpose and floating-point registers
	43	are lumped together in a single section. Unlike on NetBSD, OpenBSD
	44	uses a different layout for its general-purpose registers than the
	45	layout used for ptrace(2). */
	46
	47	/* From <machine/reg.h>. */
	48	const struct sparc_gregset sparc64obsd_core_gregset =
	49	{
	50	0 * 8, /* "tstate" */
	51	1 * 8, /* %pc */
	52	2 * 8, /* %npc */
	53	3 * 8, /* %y */
	54	-1, /* %fprs */
	55	-1,
	56	7 * 8, /* %g1 */
	57	22 * 8, /* %l0 */
	58	4 /* sizeof (%y) */
	59	};
	60
	61	static void
	62	sparc64obsd_supply_gregset (const struct regset *regset,
	63	struct regcache *regcache,
	64	int regnum, const void *gregs, size_t len)
	65	{
	66	const char *regs = gregs;
	67
9ea75c57	68	sparc64_supply_gregset (&sparc64obsd_core_gregset, regcache, regnum, regs);
1e067c66 MK	69	sparc64_supply_fpregset (regcache, regnum, regs + 288);
	70	}
	71	\f
	72
	73	/* Signal trampolines. */
	74
47b4f830 MK	75	/* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
	76	in virtual memory. The randomness makes it somewhat tricky to
	77	detect it, but fortunately we can rely on the fact that the start
	78	of the sigtramp routine is page-aligned. We recognize the
	79	trampoline by looking for the code that invokes the sigreturn
	80	system call. The offset where we can find that code varies from
	81	release to release.
	82
	83	By the way, the mapping mentioned above is read-only, so you cannot
	84	place a breakpoint in the signal trampoline. */
	85
	86	/* Default page size. */
1e067c66	87	static const int sparc64obsd_page_size = 8192;
47b4f830 MK	88
	89	/* Offset for sigreturn(2). */
	90	static const int sparc64obsd_sigreturn_offset[] = {
	91	0xf0, /* OpenBSD 3.8 */
	92	0xec, /* OpenBSD 3.6 */
	93	0xe8, /* OpenBSD 3.2 */
	94	-1
	95	};
1e067c66 MK	96
	97	static int
	98	sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
	99	{
	100	CORE_ADDR start_pc = (pc & ~(sparc64obsd_page_size - 1));
	101	unsigned long insn;
dc856692	102	const int *offset;
1e067c66 MK	103
	104	if (name)
	105	return 0;
	106
dc856692	107	for (offset = sparc64obsd_sigreturn_offset; *offset != -1; offset++)
24f033e8	108	{
dc856692 MK	109	/* Check for "restore %g0, SYS_sigreturn, %g1". */
	110	insn = sparc_fetch_instruction (start_pc + *offset);
	111	if (insn != 0x83e82067)
	112	continue;
1e067c66	113
dc856692 MK	114	/* Check for "t ST_SYSCALL". */
	115	insn = sparc_fetch_instruction (start_pc + *offset + 8);
	116	if (insn != 0x91d02000)
	117	continue;
	118
	119	return 1;
5a5effe1	120	}
1e067c66	121
dc856692	122	return 0;
1e067c66 MK	123	}
	124
	125	static struct sparc_frame_cache *
	126	sparc64obsd_frame_cache (struct frame_info next_frame, void *this_cache)
	127	{
	128	struct sparc_frame_cache *cache;
	129	CORE_ADDR addr;
	130
	131	if (*this_cache)
	132	return *this_cache;
	133
	134	cache = sparc_frame_cache (next_frame, this_cache);
	135	gdb_assert (cache == *this_cache);
	136
	137	/* If we couldn't find the frame's function, we're probably dealing
	138	with an on-stack signal trampoline. */
	139	if (cache->pc == 0)
	140	{
	141	cache->pc = frame_pc_unwind (next_frame);
	142	cache->pc &= ~(sparc64obsd_page_size - 1);
	143
	144	/* Since we couldn't find the frame's function, the cache was
	145	initialized under the assumption that we're frameless. */
	146	cache->frameless_p = 0;
	147	addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
5b2d44a0 MK	148	if (addr & 1)
5b2d44a0 MK	149	addr += BIAS;
1e067c66 MK	150	cache->base = addr;
	151	}
	152
	153	/* We find the appropriate instance of `struct sigcontext' at a
	154	fixed offset in the signal frame. */
5b2d44a0	155	addr = cache->base + 128 + 16;
1e067c66 MK	156	cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame);
	157
	158	return cache;
	159	}
	160
	161	static void
	162	sparc64obsd_frame_this_id (struct frame_info next_frame, void *this_cache,
	163	struct frame_id *this_id)
	164	{
	165	struct sparc_frame_cache *cache =
	166	sparc64obsd_frame_cache (next_frame, this_cache);
	167
	168	(*this_id) = frame_id_build (cache->base, cache->pc);
	169	}
	170
	171	static void
	172	sparc64obsd_frame_prev_register (struct frame_info *next_frame,
	173	void **this_cache,
	174	int regnum, int *optimizedp,
	175	enum lval_type lvalp, CORE_ADDR addrp,
47ef841b	176	int realnump, gdb_byte valuep)
1e067c66 MK	177	{
	178	struct sparc_frame_cache *cache =
	179	sparc64obsd_frame_cache (next_frame, this_cache);
	180
1f67027d AC	181	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
1f67027d AC	182	optimizedp, lvalp, addrp, realnump, valuep);
1e067c66 MK	183	}
	184
	185	static const struct frame_unwind sparc64obsd_frame_unwind =
	186	{
	187	SIGTRAMP_FRAME,
	188	sparc64obsd_frame_this_id,
	189	sparc64obsd_frame_prev_register
	190	};
	191
	192	static const struct frame_unwind *
	193	sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
	194	{
	195	CORE_ADDR pc = frame_pc_unwind (next_frame);
	196	char *name;
	197
	198	find_pc_partial_function (pc, &name, NULL, NULL);
	199	if (sparc64obsd_pc_in_sigtramp (pc, name))
	200	return &sparc64obsd_frame_unwind;
	201
	202	return NULL;
	203	}
	204	\f
6df5070e MK	205	/* Kernel debugging support. */
	206
	207	static struct sparc_frame_cache *
93d42b30	208	sparc64obsd_trapframe_cache (struct frame_info next_frame, void *this_cache)
6df5070e MK	209	{
	210	struct sparc_frame_cache *cache;
	211	CORE_ADDR sp, trapframe_addr;
	212	int regnum;
	213
	214	if (*this_cache)
	215	return *this_cache;
	216
	217	cache = sparc_frame_cache (next_frame, this_cache);
	218	gdb_assert (cache == *this_cache);
	219
	220	sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
	221	trapframe_addr = sp + BIAS + 176;
	222
	223	cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
	224
	225	cache->saved_regs[SPARC64_STATE_REGNUM].addr = trapframe_addr;
	226	cache->saved_regs[SPARC64_PC_REGNUM].addr = trapframe_addr + 8;
	227	cache->saved_regs[SPARC64_NPC_REGNUM].addr = trapframe_addr + 16;
	228
	229	for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
	230	cache->saved_regs[regnum].addr =
	231	trapframe_addr + 48 + (regnum - SPARC_G0_REGNUM) * 8;
	232
	233	return cache;
	234	}
	235
	236	static void
	237	sparc64obsd_trapframe_this_id (struct frame_info *next_frame,
	238	void *this_cache, struct frame_id this_id)
	239	{
	240	struct sparc_frame_cache *cache =
	241	sparc64obsd_trapframe_cache (next_frame, this_cache);
	242
	243	(*this_id) = frame_id_build (cache->base, cache->pc);
	244	}
	245
	246	static void
	247	sparc64obsd_trapframe_prev_register (struct frame_info *next_frame,
	248	void **this_cache,
	249	int regnum, int *optimizedp,
	250	enum lval_type lvalp, CORE_ADDR addrp,
	251	int realnump, gdb_byte valuep)
	252	{
	253	struct sparc_frame_cache *cache =
	254	sparc64obsd_trapframe_cache (next_frame, this_cache);
	255
	256	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
	257	optimizedp, lvalp, addrp, realnump, valuep);
	258	}
	259
	260	static const struct frame_unwind sparc64obsd_trapframe_unwind =
	261	{
	262	NORMAL_FRAME,
	263	sparc64obsd_trapframe_this_id,
	264	sparc64obsd_trapframe_prev_register
	265	};
	266
	267	static const struct frame_unwind *
	268	sparc64obsd_trapframe_sniffer (struct frame_info *next_frame)
	269	{
93d42b30	270	CORE_ADDR pc;
6df5070e MK	271	ULONGEST pstate;
	272	char *name;
	273
	274	/* Check whether we are in privileged mode, and bail out if we're not. */
93d42b30	275	pstate = frame_unwind_register_unsigned (next_frame, SPARC64_PSTATE_REGNUM);
6df5070e MK	276	if ((pstate & SPARC64_PSTATE_PRIV) == 0)
	277	return NULL;
	278
93d42b30 DJ	279	pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
93d42b30 DJ	280	find_pc_partial_function (pc, &name, NULL, NULL);
6df5070e MK	281	if (name && strcmp (name, "Lslowtrap_reenter") == 0)
	282	return &sparc64obsd_trapframe_unwind;
	283
	284	return NULL;
	285	}
	286	\f
1e067c66	287
585e38ed MK	288	/* Threads support. */
	289
	290	/* Offset wthin the thread structure where we can find %fp and %i7. */
	291	#define SPARC64OBSD_UTHREAD_FP_OFFSET 232
	292	#define SPARC64OBSD_UTHREAD_PC_OFFSET 240
	293
	294	static void
	295	sparc64obsd_supply_uthread (struct regcache *regcache,
	296	int regnum, CORE_ADDR addr)
	297	{
	298	CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
	299	gdb_byte buf[8];
	300
	301	gdb_assert (regnum >= -1);
	302
	303	fp = read_memory_unsigned_integer (fp_addr, 8);
	304	if (regnum == SPARC_SP_REGNUM \|\| regnum == -1)
	305	{
	306	store_unsigned_integer (buf, 8, fp);
	307	regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
	308
	309	if (regnum == SPARC_SP_REGNUM)
	310	return;
	311	}
	312
	313	if (regnum == SPARC64_PC_REGNUM \|\| regnum == SPARC64_NPC_REGNUM
	314	\|\| regnum == -1)
	315	{
	316	CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
	317
	318	i7 = read_memory_unsigned_integer (i7_addr, 8);
	319	if (regnum == SPARC64_PC_REGNUM \|\| regnum == -1)
	320	{
	321	store_unsigned_integer (buf, 8, i7 + 8);
	322	regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
	323	}
	324	if (regnum == SPARC64_NPC_REGNUM \|\| regnum == -1)
	325	{
	326	store_unsigned_integer (buf, 8, i7 + 12);
	327	regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf);
	328	}
	329
	330	if (regnum == SPARC64_PC_REGNUM \|\| regnum == SPARC64_NPC_REGNUM)
	331	return;
	332	}
	333
	334	sparc_supply_rwindow (regcache, fp, regnum);
	335	}
	336
	337	static void
	338	sparc64obsd_collect_uthread(const struct regcache *regcache,
	339	int regnum, CORE_ADDR addr)
	340	{
	341	CORE_ADDR sp;
	342	gdb_byte buf[8];
	343
	344	gdb_assert (regnum >= -1);
	345
	346	if (regnum == SPARC_SP_REGNUM \|\| regnum == -1)
	347	{
	348	CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
	349
	350	regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
	351	write_memory (fp_addr,buf, 8);
352	}
353
354	if (regnum == SPARC64_PC_REGNUM \|\| regnum == -1)
355	{
356	CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
357
358	regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf);
359	i7 = extract_unsigned_integer (buf, 8) - 8;
360	write_memory_unsigned_integer (i7_addr, 8, i7);
361
362	if (regnum == SPARC64_PC_REGNUM)
363	return;
364	}
365
366	regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
367	sp = extract_unsigned_integer (buf, 8);
368	sparc_collect_rwindow (regcache, sp, regnum);
369	}
370	\f
371
1e067c66 MK	372	static void
	373	sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	374	{
	375	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	376
9ea75c57	377	tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
1e067c66 MK	378	tdep->sizeof_gregset = 832;
1e067c66 MK	379
c893be75 MK	380	/* Make sure we can single-step "new" syscalls. */
	381	tdep->step_trap = sparcnbsd_step_trap;
	382
1e067c66	383	frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer);
6df5070e	384	frame_unwind_append_sniffer (gdbarch, sparc64obsd_trapframe_sniffer);
1e067c66 MK	385
	386	sparc64_init_abi (info, gdbarch);
	387
5b2d44a0	388	/* OpenBSD/sparc64 has SVR4-style shared libraries. */
1e067c66	389	set_solib_svr4_fetch_link_map_offsets
3510d1f2	390	(gdbarch, svr4_lp64_fetch_link_map_offsets);
4807909c	391	set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver);
585e38ed MK	392
	393	/* OpenBSD provides a user-level threads implementation. */
	394	bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread);
	395	bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread);
1e067c66	396	}
1e067c66	397	\f
5b2d44a0	398
1e067c66 MK	399	/* Provide a prototype to silence -Wmissing-prototypes. */
	400	void _initialize_sparc64obsd_tdep (void);
	401
	402	void
	403	_initialize_sparc64obsd_tdep (void)
	404	{
	405	gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
	406	GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
	407	}