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

/* Target-dependent code for OpenBSD/sparc64.

   Copyright (C) 2004-2021 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 "inferior.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].set_addr (trapframe_addr);
  cache->saved_regs[SPARC64_PC_REGNUM].set_addr (trapframe_addr + 8);
  cache->saved_regs[SPARC64_NPC_REGNUM].set_addr (trapframe_addr + 16);

  for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
    cache->saved_regs[regnum].set_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];

  /* This function calls functions that depend on the global current thread.  */
  gdb_assert (regcache->ptid () == inferior_ptid);

  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];

  /* This function calls functions that depend on the global current thread.  */
  gdb_assert (regcache->ptid () == inferior_ptid);

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