[thirdparty/binutils-gdb.git] / gdb / sparc64-obsd-tdep.c

/* Target-dependent code for OpenBSD/sparc64.

   Copyright (C) 2004-2018 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 "obsd-tdep.h"
#include "sparc64-tdep.h"
#include "solib-svr4.h"
#include "bsd-uthread.h"

/* Older OpenBSD versions used the traditional NetBSD core file
   format, even for ports that use ELF.  These 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).

   Newer OpenBSD versions use ELF core files.  Here the register sets
   match the ptrace(2) layout.  */

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

const struct sparc_gregmap sparc64obsd_core_gregmap =
{
  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 void *fpregs = (char *)gregs + 288;

  if (len < 832)
    {
      sparc64_supply_gregset (&sparc64obsd_gregmap, regcache, regnum, gregs);
      return;
    }

  sparc64_supply_gregset (&sparc64obsd_core_gregmap, regcache, regnum, gregs);
  sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
}

static void
sparc64obsd_supply_fpregset (const struct regset *regset,
			     struct regcache *regcache,
			     int regnum, const void *fpregs, size_t len)
{
  sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
}
\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, const 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 (struct sparc_frame_cache *) *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.  */
      sparc_record_save_insn (cache);
      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);
  const 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,
  default_frame_unwind_stop_reason,
  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 (struct sparc_frame_cache *) *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;
  const 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,
  default_frame_unwind_stop_reason,
  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 = regcache->arch ();
  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 (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 (SPARC64_PC_REGNUM, buf);
	}
      if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
	{
	  store_unsigned_integer (buf, 8, byte_order, i7 + 12);
	  regcache->raw_supply (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 = regcache->arch ();
  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 (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 (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 (SPARC_SP_REGNUM, buf);
  sp = extract_unsigned_integer (buf, 8, byte_order);
  sparc_collect_rwindow (regcache, sp, regnum);
}
\f

static const struct regset sparc64obsd_gregset =
  {
    NULL, sparc64obsd_supply_gregset, NULL
  };

static const struct regset sparc64obsd_fpregset =
  {
    NULL, sparc64obsd_supply_fpregset, NULL
  };

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

  tdep->gregset = &sparc64obsd_gregset;
  tdep->sizeof_gregset = 288;
  tdep->fpregset = &sparc64obsd_fpregset;
  tdep->sizeof_fpregset = 272;

  /* 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);
  obsd_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);
}

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