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

/* Target-dependent code for NetBSD/sparc.

   Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
   Contributed by Wasabi Systems, 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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "floatformat.h"
#include "frame.h"
#include "frame-unwind.h"
#include "gdbcore.h"
#include "osabi.h"
#include "regcache.h"
#include "regset.h"
#include "solib-svr4.h"
#include "symtab.h"
#include "trad-frame.h"

#include "gdb_assert.h"
#include "gdb_string.h"

#include "sparc-tdep.h"
#include "nbsd-tdep.h"

const struct sparc_gregset sparc32nbsd_gregset =
{
  0 * 4,			/* %psr */
  1 * 4,			/* %pc */
  2 * 4,			/* %npc */
  3 * 4,			/* %y */
  -1,				/* %wim */
  -1,				/* %tbr */
  5 * 4,			/* %g1 */
  -1				/* %l0 */
};

static void
sparc32nbsd_supply_gregset (const struct regset *regset,
			    struct regcache *regcache,
			    int regnum, const void *gregs, size_t len)
{
  sparc32_supply_gregset (&sparc32nbsd_gregset, regcache, regnum, gregs);

  /* Traditional NetBSD core files don't use multiple register sets.
     Instead, the general-purpose and floating-point registers are
     lumped together in a single section.  */
  if (len >= 212)
    sparc32_supply_fpregset (regcache, regnum, (const char *) gregs + 80);
}

static void
sparc32nbsd_supply_fpregset (const struct regset *regset,
			     struct regcache *regcache,
			     int regnum, const void *fpregs, size_t len)
{
  sparc32_supply_fpregset (regcache, regnum, fpregs);
}

\f
/* Signal trampolines.  */

/* The following variables describe the location of an on-stack signal
   trampoline.  The current values correspond to the memory layout for
   NetBSD 1.3 and up.  These shouldn't be necessary for NetBSD 2.0 and
   up, since NetBSD uses signal trampolines provided by libc now.  */

static const CORE_ADDR sparc32nbsd_sigtramp_start = 0xeffffef0;
static const CORE_ADDR sparc32nbsd_sigtramp_end = 0xeffffff0;

static int
sparc32nbsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
  if (pc >= sparc32nbsd_sigtramp_start && pc < sparc32nbsd_sigtramp_end)
    return 1;

  return nbsd_pc_in_sigtramp (pc, name);
}

struct trad_frame_saved_reg *
sparc32nbsd_sigcontext_saved_regs (struct frame_info *next_frame)
{
  struct trad_frame_saved_reg *saved_regs;
  CORE_ADDR addr, sigcontext_addr;
  int regnum, delta;
  ULONGEST psr;

  saved_regs = trad_frame_alloc_saved_regs (next_frame);

  /* We find the appropriate instance of `struct sigcontext' at a
     fixed offset in the signal frame.  */
  addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
  sigcontext_addr = addr + 64 + 16;

  /* The registers are saved in bits and pieces scattered all over the
     place.  The code below records their location on the assumption
     that the part of the signal trampoline that saves the state has
     been executed.  */

  saved_regs[SPARC_SP_REGNUM].addr = sigcontext_addr + 8;
  saved_regs[SPARC32_PC_REGNUM].addr = sigcontext_addr + 12;
  saved_regs[SPARC32_NPC_REGNUM].addr = sigcontext_addr + 16;
  saved_regs[SPARC32_PSR_REGNUM].addr = sigcontext_addr + 20;
  saved_regs[SPARC_G1_REGNUM].addr = sigcontext_addr + 24;
  saved_regs[SPARC_O0_REGNUM].addr = sigcontext_addr + 28;

  /* The remaining `global' registers and %y are saved in the `local'
     registers.  */
  delta = SPARC_L0_REGNUM - SPARC_G0_REGNUM;
  for (regnum = SPARC_G2_REGNUM; regnum <= SPARC_G7_REGNUM; regnum++)
    saved_regs[regnum].realreg = regnum + delta;
  saved_regs[SPARC32_Y_REGNUM].realreg = SPARC_L1_REGNUM;

  /* The remaining `out' registers can be found in the current frame's
     `in' registers.  */
  delta = SPARC_I0_REGNUM - SPARC_O0_REGNUM;
  for (regnum = SPARC_O1_REGNUM; regnum <= SPARC_O5_REGNUM; regnum++)
    saved_regs[regnum].realreg = regnum + delta;
  saved_regs[SPARC_O7_REGNUM].realreg = SPARC_I7_REGNUM;

  /* The `local' and `in' registers have been saved in the register
     save area.  */
  addr = saved_regs[SPARC_SP_REGNUM].addr;
  addr = get_frame_memory_unsigned (next_frame, addr, 4);
  for (regnum = SPARC_L0_REGNUM;
       regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
    saved_regs[regnum].addr = addr;

  /* Handle StackGhost.  */
  {
    ULONGEST wcookie = sparc_fetch_wcookie ();

    if (wcookie != 0)
      {
	ULONGEST i7;

	addr = saved_regs[SPARC_I7_REGNUM].addr;
	i7 = get_frame_memory_unsigned (next_frame, addr, 4);
	trad_frame_set_value (saved_regs, SPARC_I7_REGNUM, i7 ^ wcookie);
      }
  }

  /* The floating-point registers are only saved if the EF bit in %prs
     has been set.  */

#define PSR_EF	0x00001000

  addr = saved_regs[SPARC32_PSR_REGNUM].addr;
  psr = get_frame_memory_unsigned (next_frame, addr, 4);
  if (psr & PSR_EF)
    {
      CORE_ADDR sp;

      sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
      saved_regs[SPARC32_FSR_REGNUM].addr = sp + 96;
      for (regnum = SPARC_F0_REGNUM, addr = sp + 96 + 8;
	   regnum <= SPARC_F31_REGNUM; regnum++, addr += 4)
	saved_regs[regnum].addr = addr;
    }

  return saved_regs;
}

static struct sparc_frame_cache *
sparc32nbsd_sigcontext_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 = sparc32nbsd_sigtramp_start;

      /* 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);
      cache->base = addr;
    }

  cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (next_frame);

  return cache;
}

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

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

static void
sparc32nbsd_sigcontext_frame_prev_register (struct frame_info *next_frame,
					    void **this_cache,
					    int regnum, int *optimizedp,
					    enum lval_type *lvalp,
					    CORE_ADDR *addrp,
					    int *realnump, void *valuep)
{
  struct sparc_frame_cache *cache =
    sparc32nbsd_sigcontext_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 sparc32nbsd_sigcontext_frame_unwind =
{
  SIGTRAMP_FRAME,
  sparc32nbsd_sigcontext_frame_this_id,
  sparc32nbsd_sigcontext_frame_prev_register
};

static const struct frame_unwind *
sparc32nbsd_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 (sparc32nbsd_pc_in_sigtramp (pc, name))
    {
      if (name == NULL || strncmp (name, "__sigtramp_sigcontext", 21))
	return &sparc32nbsd_sigcontext_frame_unwind;
    }

  return NULL;
}
\f

/* Return non-zero if we are in a shared library trampoline code stub.  */

static int
sparcnbsd_aout_in_solib_call_trampoline (CORE_ADDR pc, char *name)
{
  return (name && !strcmp (name, "_DYNAMIC"));
}

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

  /* NetBSD doesn't support the 128-bit `long double' from the psABI.  */
  set_gdbarch_long_double_bit (gdbarch, 64);
  set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);

  tdep->gregset = regset_alloc (gdbarch, sparc32nbsd_supply_gregset, NULL);
  tdep->sizeof_gregset = 20 * 4;

  tdep->fpregset = regset_alloc (gdbarch, sparc32nbsd_supply_fpregset, NULL);
  tdep->sizeof_fpregset = 33 * 4;

  frame_unwind_append_sniffer (gdbarch, sparc32nbsd_sigtramp_frame_sniffer);
}

static void
sparc32nbsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  sparc32nbsd_init_abi (info, gdbarch);

  set_gdbarch_in_solib_call_trampoline
    (gdbarch, sparcnbsd_aout_in_solib_call_trampoline);
}

static void
sparc32nbsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  sparc32nbsd_init_abi (info, gdbarch);

  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, nbsd_ilp32_solib_svr4_fetch_link_map_offsets);
}

static enum gdb_osabi
sparcnbsd_aout_osabi_sniffer (bfd *abfd)
{
  if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)
    return GDB_OSABI_NETBSD_AOUT;

  return GDB_OSABI_UNKNOWN;
}

/* OpenBSD uses the traditional NetBSD core file format, even for
   ports that use ELF.  Therefore, if the default OS ABI is OpenBSD
   ELF, we return that instead of NetBSD a.out.  This is mainly for
   the benfit of OpenBSD/sparc64, which inherits the sniffer below
   since we include this file for an OpenBSD/sparc64 target.  For
   OpenBSD/sparc, the NetBSD a.out OS ABI is probably similar enough
   to both the OpenBSD a.out and the OpenBSD ELF OS ABI.  */
#if defined (GDB_OSABI_DEFAULT) && (GDB_OSABI_DEFAULT == GDB_OSABI_OPENBSD_ELF)
#define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
#else
#define GDB_OSABI_NETBSD_CORE GDB_OSABI_NETBSD_AOUT
#endif

static enum gdb_osabi
sparcnbsd_core_osabi_sniffer (bfd *abfd)
{
  if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
    return GDB_OSABI_NETBSD_CORE;

  return GDB_OSABI_UNKNOWN;
}

\f
/* Provide a prototype to silence -Wmissing-prototypes.  */
void _initialize_sparcnbsd_tdep (void);

void
_initialize_sparnbsd_tdep (void)
{
  gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,
				  sparcnbsd_aout_osabi_sniffer);

  /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
  gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_unknown_flavour,
                                  sparcnbsd_core_osabi_sniffer);

  gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_AOUT,
			  sparc32nbsd_aout_init_abi);
  gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_ELF,
			  sparc32nbsd_elf_init_abi);
}
Commit	Line	Data
386c036b MK	1	/* Target-dependent code for NetBSD/sparc.
	2
	3	Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
9ce5c36a JT	4	Contributed by Wasabi Systems, Inc.
	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
	10	the Free Software Foundation; either version 2 of the License, or
	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
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
	23	#include "defs.h"
386c036b MK	24	#include "floatformat.h"
	25	#include "frame.h"
	26	#include "frame-unwind.h"
9ce5c36a	27	#include "gdbcore.h"
9ce5c36a	28	#include "osabi.h"
386c036b	29	#include "regcache.h"
4e7b0cd3	30	#include "regset.h"
386c036b MK	31	#include "solib-svr4.h"
	32	#include "symtab.h"
	33	#include "trad-frame.h"
9ce5c36a	34
386c036b	35	#include "gdb_assert.h"
f6ad61e3 MK	36	#include "gdb_string.h"
f6ad61e3 MK	37
c139e7d9	38	#include "sparc-tdep.h"
9ce5c36a JT	39	#include "nbsd-tdep.h"
9ce5c36a JT	40
386c036b	41	const struct sparc_gregset sparc32nbsd_gregset =
9ce5c36a	42	{
386c036b MK	43	0 * 4, /* %psr */
	44	1 * 4, /* %pc */
	45	2 * 4, /* %npc */
	46	3 * 4, /* %y */
	47	-1, /* %wim */
	48	-1, /* %tbr */
	49	5 * 4, /* %g1 */
	50	-1 /* %l0 */
	51	};
9ce5c36a	52
9ce5c36a	53	static void
4e7b0cd3 MK	54	sparc32nbsd_supply_gregset (const struct regset *regset,
	55	struct regcache *regcache,
	56	int regnum, const void *gregs, size_t len)
9ce5c36a	57	{
9ea75c57	58	sparc32_supply_gregset (&sparc32nbsd_gregset, regcache, regnum, gregs);
c8e737d5 MK	59
	60	/* Traditional NetBSD core files don't use multiple register sets.
	61	Instead, the general-purpose and floating-point registers are
	62	lumped together in a single section. */
	63	if (len >= 212)
	64	sparc32_supply_fpregset (regcache, regnum, (const char *) gregs + 80);
9ce5c36a JT	65	}
9ce5c36a JT	66
4e7b0cd3 MK	67	static void
	68	sparc32nbsd_supply_fpregset (const struct regset *regset,
	69	struct regcache *regcache,
	70	int regnum, const void *fpregs, size_t len)
9ce5c36a	71	{
4e7b0cd3 MK	72	sparc32_supply_fpregset (regcache, regnum, fpregs);
4e7b0cd3 MK	73	}
9ce5c36a	74
386c036b MK	75	\f
	76	/* Signal trampolines. */
	77
	78	/* The following variables describe the location of an on-stack signal
	79	trampoline. The current values correspond to the memory layout for
	80	NetBSD 1.3 and up. These shouldn't be necessary for NetBSD 2.0 and
	81	up, since NetBSD uses signal trampolines provided by libc now. */
9ce5c36a	82
386c036b MK	83	static const CORE_ADDR sparc32nbsd_sigtramp_start = 0xeffffef0;
386c036b MK	84	static const CORE_ADDR sparc32nbsd_sigtramp_end = 0xeffffff0;
9ce5c36a JT	85
9ce5c36a JT	86	static int
386c036b MK	87	sparc32nbsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
	88	{
	89	if (pc >= sparc32nbsd_sigtramp_start && pc < sparc32nbsd_sigtramp_end)
	90	return 1;
	91
	92	return nbsd_pc_in_sigtramp (pc, name);
	93	}
	94
566626fa MK	95	struct trad_frame_saved_reg *
566626fa MK	96	sparc32nbsd_sigcontext_saved_regs (struct frame_info *next_frame)
9ce5c36a	97	{
566626fa	98	struct trad_frame_saved_reg *saved_regs;
386c036b	99	CORE_ADDR addr, sigcontext_addr;
386c036b	100	int regnum, delta;
566626fa	101	ULONGEST psr;
9ce5c36a	102
566626fa	103	saved_regs = trad_frame_alloc_saved_regs (next_frame);
9ce5c36a	104
566626fa MK	105	/* We find the appropriate instance of `struct sigcontext' at a
	106	fixed offset in the signal frame. */
	107	addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
	108	sigcontext_addr = addr + 64 + 16;
9ce5c36a	109
386c036b MK	110	/* The registers are saved in bits and pieces scattered all over the
	111	place. The code below records their location on the assumption
	112	that the part of the signal trampoline that saves the state has
	113	been executed. */
9ce5c36a	114
566626fa MK	115	saved_regs[SPARC_SP_REGNUM].addr = sigcontext_addr + 8;
	116	saved_regs[SPARC32_PC_REGNUM].addr = sigcontext_addr + 12;
	117	saved_regs[SPARC32_NPC_REGNUM].addr = sigcontext_addr + 16;
	118	saved_regs[SPARC32_PSR_REGNUM].addr = sigcontext_addr + 20;
	119	saved_regs[SPARC_G1_REGNUM].addr = sigcontext_addr + 24;
	120	saved_regs[SPARC_O0_REGNUM].addr = sigcontext_addr + 28;
386c036b MK	121
	122	/* The remaining `global' registers and %y are saved in the `local'
	123	registers. */
	124	delta = SPARC_L0_REGNUM - SPARC_G0_REGNUM;
	125	for (regnum = SPARC_G2_REGNUM; regnum <= SPARC_G7_REGNUM; regnum++)
566626fa MK	126	saved_regs[regnum].realreg = regnum + delta;
566626fa MK	127	saved_regs[SPARC32_Y_REGNUM].realreg = SPARC_L1_REGNUM;
386c036b MK	128
	129	/* The remaining `out' registers can be found in the current frame's
	130	`in' registers. */
	131	delta = SPARC_I0_REGNUM - SPARC_O0_REGNUM;
	132	for (regnum = SPARC_O1_REGNUM; regnum <= SPARC_O5_REGNUM; regnum++)
566626fa MK	133	saved_regs[regnum].realreg = regnum + delta;
566626fa MK	134	saved_regs[SPARC_O7_REGNUM].realreg = SPARC_I7_REGNUM;
386c036b MK	135
	136	/* The `local' and `in' registers have been saved in the register
	137	save area. */
566626fa	138	addr = saved_regs[SPARC_SP_REGNUM].addr;
386c036b MK	139	addr = get_frame_memory_unsigned (next_frame, addr, 4);
	140	for (regnum = SPARC_L0_REGNUM;
	141	regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
566626fa	142	saved_regs[regnum].addr = addr;
386c036b	143
1c800673 MK	144	/* Handle StackGhost. */
	145	{
	146	ULONGEST wcookie = sparc_fetch_wcookie ();
	147
	148	if (wcookie != 0)
	149	{
	150	ULONGEST i7;
	151
	152	addr = saved_regs[SPARC_I7_REGNUM].addr;
	153	i7 = get_frame_memory_unsigned (next_frame, addr, 4);
	154	trad_frame_set_value (saved_regs, SPARC_I7_REGNUM, i7 ^ wcookie);
	155	}
	156	}
	157
386c036b MK	158	/* The floating-point registers are only saved if the EF bit in %prs
	159	has been set. */
	160
	161	#define PSR_EF 0x00001000
	162
566626fa	163	addr = saved_regs[SPARC32_PSR_REGNUM].addr;
386c036b MK	164	psr = get_frame_memory_unsigned (next_frame, addr, 4);
	165	if (psr & PSR_EF)
	166	{
	167	CORE_ADDR sp;
	168
	169	sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
566626fa	170	saved_regs[SPARC32_FSR_REGNUM].addr = sp + 96;
386c036b MK	171	for (regnum = SPARC_F0_REGNUM, addr = sp + 96 + 8;
386c036b MK	172	regnum <= SPARC_F31_REGNUM; regnum++, addr += 4)
566626fa MK	173	saved_regs[regnum].addr = addr;
	174	}
	175
	176	return saved_regs;
	177	}
	178
	179	static struct sparc_frame_cache *
	180	sparc32nbsd_sigcontext_frame_cache (struct frame_info *next_frame,
	181	void **this_cache)
	182	{
	183	struct sparc_frame_cache *cache;
	184	CORE_ADDR addr;
	185
	186	if (*this_cache)
	187	return *this_cache;
	188
	189	cache = sparc_frame_cache (next_frame, this_cache);
	190	gdb_assert (cache == *this_cache);
	191
	192	/* If we couldn't find the frame's function, we're probably dealing
	193	with an on-stack signal trampoline. */
	194	if (cache->pc == 0)
	195	{
	196	cache->pc = sparc32nbsd_sigtramp_start;
	197
	198	/* Since we couldn't find the frame's function, the cache was
	199	initialized under the assumption that we're frameless. */
	200	cache->frameless_p = 0;
	201	addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
	202	cache->base = addr;
386c036b MK	203	}
386c036b MK	204
566626fa MK	205	cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (next_frame);
566626fa MK	206
386c036b	207	return cache;
9ce5c36a JT	208	}
9ce5c36a JT	209
386c036b MK	210	static void
	211	sparc32nbsd_sigcontext_frame_this_id (struct frame_info *next_frame,
	212	void **this_cache,
	213	struct frame_id *this_id)
	214	{
	215	struct sparc_frame_cache *cache =
	216	sparc32nbsd_sigcontext_frame_cache (next_frame, this_cache);
	217
	218	(*this_id) = frame_id_build (cache->base, cache->pc);
	219	}
	220
	221	static void
	222	sparc32nbsd_sigcontext_frame_prev_register (struct frame_info *next_frame,
	223	void **this_cache,
	224	int regnum, int *optimizedp,
	225	enum lval_type *lvalp,
	226	CORE_ADDR *addrp,
	227	int realnump, void valuep)
9ce5c36a	228	{
386c036b MK	229	struct sparc_frame_cache *cache =
386c036b MK	230	sparc32nbsd_sigcontext_frame_cache (next_frame, this_cache);
9ce5c36a	231
1f67027d AC	232	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
1f67027d AC	233	optimizedp, lvalp, addrp, realnump, valuep);
386c036b	234	}
9ce5c36a	235
386c036b MK	236	static const struct frame_unwind sparc32nbsd_sigcontext_frame_unwind =
	237	{
	238	SIGTRAMP_FRAME,
	239	sparc32nbsd_sigcontext_frame_this_id,
	240	sparc32nbsd_sigcontext_frame_prev_register
	241	};
9ce5c36a	242
386c036b MK	243	static const struct frame_unwind *
	244	sparc32nbsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
	245	{
	246	CORE_ADDR pc = frame_pc_unwind (next_frame);
	247	char *name;
9ce5c36a	248
386c036b MK	249	find_pc_partial_function (pc, &name, NULL, NULL);
	250	if (sparc32nbsd_pc_in_sigtramp (pc, name))
	251	{
	252	if (name == NULL \|\| strncmp (name, "__sigtramp_sigcontext", 21))
	253	return &sparc32nbsd_sigcontext_frame_unwind;
	254	}
	255
	256	return NULL;
9ce5c36a	257	}
386c036b MK	258	\f
	259
	260	/* Return non-zero if we are in a shared library trampoline code stub. */
9ce5c36a JT	261
	262	static int
	263	sparcnbsd_aout_in_solib_call_trampoline (CORE_ADDR pc, char *name)
	264	{
386c036b	265	return (name && !strcmp (name, "_DYNAMIC"));
9ce5c36a JT	266	}
	267
	268	static void
386c036b	269	sparc32nbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
9ce5c36a	270	{
4e7b0cd3 MK	271	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4e7b0cd3 MK	272
386c036b MK	273	/* NetBSD doesn't support the 128-bit `long double' from the psABI. */
	274	set_gdbarch_long_double_bit (gdbarch, 64);
	275	set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
	276
9ea75c57	277	tdep->gregset = regset_alloc (gdbarch, sparc32nbsd_supply_gregset, NULL);
c8e737d5	278	tdep->sizeof_gregset = 20 * 4;
4e7b0cd3	279
9ea75c57	280	tdep->fpregset = regset_alloc (gdbarch, sparc32nbsd_supply_fpregset, NULL);
c8e737d5	281	tdep->sizeof_fpregset = 33 * 4;
4e7b0cd3	282
386c036b	283	frame_unwind_append_sniffer (gdbarch, sparc32nbsd_sigtramp_frame_sniffer);
9ce5c36a JT	284	}
	285
	286	static void
386c036b	287	sparc32nbsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
9ce5c36a	288	{
386c036b	289	sparc32nbsd_init_abi (info, gdbarch);
9ce5c36a	290
386c036b MK	291	set_gdbarch_in_solib_call_trampoline
386c036b MK	292	(gdbarch, sparcnbsd_aout_in_solib_call_trampoline);
9ce5c36a JT	293	}
	294
	295	static void
386c036b	296	sparc32nbsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
9ce5c36a	297	{
386c036b	298	sparc32nbsd_init_abi (info, gdbarch);
9ce5c36a	299
386c036b MK	300	set_solib_svr4_fetch_link_map_offsets
386c036b MK	301	(gdbarch, nbsd_ilp32_solib_svr4_fetch_link_map_offsets);
9ce5c36a JT	302	}
	303
	304	static enum gdb_osabi
	305	sparcnbsd_aout_osabi_sniffer (bfd *abfd)
	306	{
	307	if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)
	308	return GDB_OSABI_NETBSD_AOUT;
	309
	310	return GDB_OSABI_UNKNOWN;
	311	}
	312
7e5e9f88 MK	313	/* OpenBSD uses the traditional NetBSD core file format, even for
	314	ports that use ELF. Therefore, if the default OS ABI is OpenBSD
	315	ELF, we return that instead of NetBSD a.out. This is mainly for
	316	the benfit of OpenBSD/sparc64, which inherits the sniffer below
	317	since we include this file for an OpenBSD/sparc64 target. For
	318	OpenBSD/sparc, the NetBSD a.out OS ABI is probably similar enough
	319	to both the OpenBSD a.out and the OpenBSD ELF OS ABI. */
	320	#if defined (GDB_OSABI_DEFAULT) && (GDB_OSABI_DEFAULT == GDB_OSABI_OPENBSD_ELF)
	321	#define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
	322	#else
	323	#define GDB_OSABI_NETBSD_CORE GDB_OSABI_NETBSD_AOUT
	324	#endif
	325
89aac506 MK	326	static enum gdb_osabi
	327	sparcnbsd_core_osabi_sniffer (bfd *abfd)
	328	{
	329	if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
7e5e9f88	330	return GDB_OSABI_NETBSD_CORE;
89aac506 MK	331
	332	return GDB_OSABI_UNKNOWN;
	333	}
	334
386c036b MK	335	\f
	336	/* Provide a prototype to silence -Wmissing-prototypes. */
	337	void _initialize_sparcnbsd_tdep (void);
	338
9ce5c36a JT	339	void
	340	_initialize_sparnbsd_tdep (void)
	341	{
	342	gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,
	343	sparcnbsd_aout_osabi_sniffer);
	344
adf93a2f MK	345	/* BFD doesn't set a flavour for NetBSD style a.out core files. */
adf93a2f MK	346	gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_unknown_flavour,
89aac506 MK	347	sparcnbsd_core_osabi_sniffer);
89aac506 MK	348
05816f70	349	gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_AOUT,
386c036b	350	sparc32nbsd_aout_init_abi);
05816f70	351	gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_ELF,
386c036b	352	sparc32nbsd_elf_init_abi);
9ce5c36a	353	}