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

/* Target-dependent code for OpenBSD/sparc64.

   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
   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 3 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, see <http://www.gnu.org/licenses/>.  */

#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 *this_frame, void **this_cache)
{
  struct sparc_frame_cache *cache;
  CORE_ADDR addr;

  if (*this_cache)
    return *this_cache;

  cache = sparc_frame_cache (this_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 = get_frame_pc (this_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 = get_frame_register_unsigned (this_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, this_frame);

  return cache;
}

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

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

static struct value *
sparc64obsd_frame_prev_register (struct frame_info *this_frame,
				 void **this_cache, int regnum)
{
  struct sparc_frame_cache *cache =
    sparc64obsd_frame_cache (this_frame, this_cache);

  return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
}

static int
sparc64obsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
				    struct frame_info *this_frame,
				    void **this_cache)
{
  CORE_ADDR pc = get_frame_pc (this_frame);
  char *name;

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

  return 0;
}

static const struct frame_unwind sparc64obsd_frame_unwind =
{
  SIGTRAMP_FRAME,
  sparc64obsd_frame_this_id,
  sparc64obsd_frame_prev_register,
  NULL,
  sparc64obsd_sigtramp_frame_sniffer
};
\f
/* Kernel debugging support.  */

static struct sparc_frame_cache *
sparc64obsd_trapframe_cache (struct frame_info *this_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 (this_frame, this_cache);
  gdb_assert (cache == *this_cache);

  sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
  trapframe_addr = sp + BIAS + 176;

  cache->saved_regs = trad_frame_alloc_saved_regs (this_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 *this_frame,
			       void **this_cache, struct frame_id *this_id)
{
  struct sparc_frame_cache *cache =
    sparc64obsd_trapframe_cache (this_frame, this_cache);

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

static struct value *
sparc64obsd_trapframe_prev_register (struct frame_info *this_frame,
				     void **this_cache, int regnum)
{
  struct sparc_frame_cache *cache =
    sparc64obsd_trapframe_cache (this_frame, this_cache);

  return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
}

static int
sparc64obsd_trapframe_sniffer (const struct frame_unwind *self,
			       struct frame_info *this_frame,
			       void **this_cache)
{
  CORE_ADDR pc;
  ULONGEST pstate;
  char *name;

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

  pc = get_frame_address_in_block (this_frame);
  find_pc_partial_function (pc, &name, NULL, NULL);
  if (name && strcmp (name, "Lslowtrap_reenter") == 0)
    return 1;

  return 0;
}

static const struct frame_unwind sparc64obsd_trapframe_unwind =
{
  NORMAL_FRAME,
  sparc64obsd_trapframe_this_id,
  sparc64obsd_trapframe_prev_register,
  NULL,
  sparc64obsd_trapframe_sniffer
};
\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)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  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, byte_order);
  if (regnum == SPARC_SP_REGNUM || regnum == -1)
    {
      store_unsigned_integer (buf, 8, byte_order, 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, byte_order);
      if (regnum == SPARC64_PC_REGNUM || regnum == -1)
	{
	  store_unsigned_integer (buf, 8, byte_order, i7 + 8);
	  regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
	}
      if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
	{
	  store_unsigned_integer (buf, 8, byte_order, 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)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  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, byte_order) - 8;
      write_memory_unsigned_integer (i7_addr, 8, byte_order, i7);

      if (regnum == SPARC64_PC_REGNUM)
	return;
    }

  regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
  sp = extract_unsigned_integer (buf, 8, byte_order);
  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_unwinder (gdbarch, &sparc64obsd_frame_unwind);
  frame_unwind_append_unwinder (gdbarch, &sparc64obsd_trapframe_unwind);

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