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

/* Target-dependent code for NetBSD/alpha.

   Copyright (C) 2002, 2003, 2004, 2006 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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include "defs.h"
#include "frame.h"
#include "gdbcore.h"
#include "osabi.h"
#include "regcache.h"
#include "regset.h"
#include "value.h"

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

#include "alpha-tdep.h"
#include "alphabsd-tdep.h"
#include "nbsd-tdep.h"
#include "solib-svr4.h"

/* Core file support.  */

/* Even though NetBSD/alpha used ELF since day one, it used the
   traditional a.out-style core dump format before NetBSD 1.6.  */

/* Sizeof `struct reg' in <machine/reg.h>.  */
#define ALPHANBSD_SIZEOF_GREGS	(32 * 8)

/* Sizeof `struct fpreg' in <machine/reg.h.  */
#define ALPHANBSD_SIZEOF_FPREGS	((32 * 8) + 8)

/* Supply register REGNUM from the buffer specified by FPREGS and LEN
   in the floating-point register set REGSET to register cache
   REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */

static void
alphanbsd_supply_fpregset (const struct regset *regset,
			   struct regcache *regcache,
			   int regnum, const void *fpregs, size_t len)
{
  const gdb_byte *regs = fpregs;
  int i;

  gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS);

  for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
    {
      if (regnum == i || regnum == -1)
	regcache_raw_supply (regcache, i, regs + (i - ALPHA_FP0_REGNUM) * 8);
    }

  if (regnum == ALPHA_FPCR_REGNUM || regnum == -1)
    regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 32 * 8);
}

/* Supply register REGNUM from the buffer specified by GREGS and LEN
   in the general-purpose register set REGSET to register cache
   REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */

static void
alphanbsd_supply_gregset (const struct regset *regset,
			  struct regcache *regcache,
			  int regnum, const void *gregs, size_t len)
{
  const gdb_byte *regs = gregs;
  int i;

  gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);

  for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
    {
      if (regnum == i || regnum == -1)
	regcache_raw_supply (regcache, i, regs + i * 8);
    }

  if (regnum == ALPHA_PC_REGNUM || regnum == -1)
    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
}

/* Supply register REGNUM from the buffer specified by GREGS and LEN
   in the general-purpose register set REGSET to register cache
   REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */

static void
alphanbsd_aout_supply_gregset (const struct regset *regset,
			       struct regcache *regcache,
			       int regnum, const void *gregs, size_t len)
{
  const gdb_byte *regs = gregs;
  int i;

  /* Table to map a GDB register number to a trapframe register index.  */
  static const int regmap[] =
  {
     0,   1,   2,   3,
     4,   5,   6,   7,
     8,   9,  10,  11,
    12,  13,  14,  15, 
    30,  31,  32,  16, 
    17,  18,  19,  20,
    21,  22,  23,  24,
    25,  29,  26
  };

  gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);

  for (i = 0; i < ARRAY_SIZE(regmap); i++)
    {
      if (regnum == i || regnum == -1)
	regcache_raw_supply (regcache, i, regs + regmap[i] * 8);
    }

  if (regnum == ALPHA_PC_REGNUM || regnum == -1)
    regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);

  if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
    {
      regs += ALPHANBSD_SIZEOF_GREGS;
      len -= ALPHANBSD_SIZEOF_GREGS;
      alphanbsd_supply_fpregset (regset, regcache, regnum, regs, len);
    }
}

/* NetBSD/alpha register sets.  */

static struct regset alphanbsd_gregset =
{
  NULL,
  alphanbsd_supply_gregset
};

static struct regset alphanbsd_fpregset =
{
  NULL,
  alphanbsd_supply_fpregset
};

static struct regset alphanbsd_aout_gregset =
{
  NULL,
  alphanbsd_aout_supply_gregset
};

/* Return the appropriate register set for the core section identified
   by SECT_NAME and SECT_SIZE.  */

static const struct regset *
alphanbsd_regset_from_core_section (struct gdbarch *gdbarch,
				    const char *sect_name, size_t sect_size)
{
  if (strcmp (sect_name, ".reg") == 0 && sect_size >= ALPHANBSD_SIZEOF_GREGS)
    return &alphanbsd_gregset;

  if (strcmp (sect_name, ".reg2") == 0 && sect_size >= ALPHANBSD_SIZEOF_FPREGS)
    return &alphanbsd_fpregset;

  return NULL;
}

static const struct regset *
alphanbsd_aout_regset_from_core_section (struct gdbarch *gdbarch,
					 const char *sect_name,
					 size_t sect_size)
{
  if (strcmp (sect_name, ".reg") == 0 && sect_size >= ALPHANBSD_SIZEOF_GREGS)
    return &alphanbsd_aout_gregset;

  return NULL;
}
\f

/* Signal trampolines.  */

/* Under NetBSD/alpha, signal handler invocations can be identified by the
   designated code sequence that is used to return from a signal handler.
   In particular, the return address of a signal handler points to the
   following code sequence:

	ldq	a0, 0(sp)
	lda	sp, 16(sp)
	lda	v0, 295(zero)	# __sigreturn14
	call_pal callsys

   Each instruction has a unique encoding, so we simply attempt to match
   the instruction the PC is pointing to with any of the above instructions.
   If there is a hit, we know the offset to the start of the designated
   sequence and can then check whether we really are executing in the
   signal trampoline.  If not, -1 is returned, otherwise the offset from the
   start of the return sequence is returned.  */
static const unsigned char sigtramp_retcode[] =
{
  0x00, 0x00, 0x1e, 0xa6,	/* ldq a0, 0(sp) */
  0x10, 0x00, 0xde, 0x23,	/* lda sp, 16(sp) */
  0x27, 0x01, 0x1f, 0x20,	/* lda v0, 295(zero) */
  0x83, 0x00, 0x00, 0x00,	/* call_pal callsys */
};
#define RETCODE_NWORDS		4
#define RETCODE_SIZE		(RETCODE_NWORDS * 4)

LONGEST
alphanbsd_sigtramp_offset (CORE_ADDR pc)
{
  unsigned char ret[RETCODE_SIZE], w[4];
  LONGEST off;
  int i;

  if (deprecated_read_memory_nobpt (pc, (char *) w, 4) != 0)
    return -1;

  for (i = 0; i < RETCODE_NWORDS; i++)
    {
      if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
	break;
    }
  if (i == RETCODE_NWORDS)
    return (-1);

  off = i * 4;
  pc -= off;

  if (deprecated_read_memory_nobpt (pc, (char *) ret, sizeof (ret)) != 0)
    return -1;

  if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
    return off;

  return -1;
}

static int
alphanbsd_pc_in_sigtramp (CORE_ADDR pc, char *func_name)
{
  return (nbsd_pc_in_sigtramp (pc, func_name)
	  || alphanbsd_sigtramp_offset (pc) >= 0);
}

static CORE_ADDR
alphanbsd_sigcontext_addr (struct frame_info *frame)
{
  /* FIXME: This is not correct for all versions of NetBSD/alpha.
     We will probably need to disassemble the trampoline to figure
     out which trampoline frame type we have.  */
  return get_frame_base (frame);
}

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

  /* Hook into the DWARF CFI frame unwinder.  */
  alpha_dwarf2_init_abi (info, gdbarch);

  /* Hook into the MDEBUG frame unwinder.  */
  alpha_mdebug_init_abi (info, gdbarch);

  /* NetBSD/alpha does not provide single step support via ptrace(2); we
     must use software single-stepping.  */
  set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);

  /* NetBSD/alpha has SVR4-style shared libraries.  */
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, svr4_lp64_fetch_link_map_offsets);

  tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset;
  tdep->pc_in_sigtramp = alphanbsd_pc_in_sigtramp;
  tdep->sigcontext_addr = alphanbsd_sigcontext_addr;

  tdep->jb_pc = 2;
  tdep->jb_elt_size = 8;

  set_gdbarch_regset_from_core_section
    (gdbarch, alphanbsd_regset_from_core_section);
}

static void
alphanbsd_aout_init_abi (struct gdbarch_info info,
			 struct gdbarch *gdbarch)
{
  alphanbsd_init_abi(info, gdbarch);

  set_gdbarch_regset_from_core_section
    (gdbarch, alphanbsd_aout_regset_from_core_section);
}
\f

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

  return GDB_OSABI_UNKNOWN;
}
\f

/* Provide a prototype to silence -Wmissing-prototypes.  */
void _initialize_alphanbsd_tdep (void);

void
_initialize_alphanbsd_tdep (void)
{
  /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
  gdbarch_register_osabi_sniffer (bfd_arch_alpha, bfd_target_unknown_flavour,
                                  alphanbsd_core_osabi_sniffer);

  gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_ELF,
                          alphanbsd_init_abi);
  gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_AOUT,
                          alphanbsd_aout_init_abi);
  gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_OPENBSD_ELF,
                          alphanbsd_aout_init_abi);
}
Commit	Line	Data
789f3b5f MK	1	/* Target-dependent code for NetBSD/alpha.
	2
	3	Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
2031c21a	4
da8ca43d JT	5	Contributed by Wasabi Systems, Inc.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
197e01b6 EZ	21	Foundation, Inc., 51 Franklin Street, Fifth Floor,
197e01b6 EZ	22	Boston, MA 02110-1301, USA. */
da8ca43d JT	23
da8ca43d JT	24	#include "defs.h"
2ca8ae21	25	#include "frame.h"
3beabdb2 MK	26	#include "gdbcore.h"
3beabdb2 MK	27	#include "osabi.h"
8513dd2d	28	#include "regcache.h"
3beabdb2	29	#include "regset.h"
da8ca43d	30	#include "value.h"
da8ca43d	31
3beabdb2	32	#include "gdb_assert.h"
cca0d3b0	33	#include "gdb_string.h"
9964235a	34
da8ca43d	35	#include "alpha-tdep.h"
8513dd2d	36	#include "alphabsd-tdep.h"
ea5bc2a6	37	#include "nbsd-tdep.h"
527ca6bb	38	#include "solib-svr4.h"
8513dd2d	39
3beabdb2 MK	40	/* Core file support. */
	41
	42	/* Even though NetBSD/alpha used ELF since day one, it used the
	43	traditional a.out-style core dump format before NetBSD 1.6. */
	44
	45	/* Sizeof `struct reg' in <machine/reg.h>. */
	46	#define ALPHANBSD_SIZEOF_GREGS (32 * 8)
	47
	48	/* Sizeof `struct fpreg' in <machine/reg.h. */
	49	#define ALPHANBSD_SIZEOF_FPREGS ((32 * 8) + 8)
	50
	51	/* Supply register REGNUM from the buffer specified by FPREGS and LEN
	52	in the floating-point register set REGSET to register cache
	53	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	54
8513dd2d	55	static void
3beabdb2 MK	56	alphanbsd_supply_fpregset (const struct regset *regset,
	57	struct regcache *regcache,
	58	int regnum, const void *fpregs, size_t len)
8513dd2d	59	{
3beabdb2 MK	60	const gdb_byte *regs = fpregs;
	61	int i;
	62
	63	gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS);
	64
	65	for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
	66	{
	67	if (regnum == i \|\| regnum == -1)
	68	regcache_raw_supply (regcache, i, regs + (i - ALPHA_FP0_REGNUM) * 8);
	69	}
	70
	71	if (regnum == ALPHA_FPCR_REGNUM \|\| regnum == -1)
	72	regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 32 * 8);
	73	}
	74
	75	/* Supply register REGNUM from the buffer specified by GREGS and LEN
	76	in the general-purpose register set REGSET to register cache
	77	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
8513dd2d	78
3beabdb2 MK	79	static void
	80	alphanbsd_supply_gregset (const struct regset *regset,
	81	struct regcache *regcache,
	82	int regnum, const void *gregs, size_t len)
	83	{
	84	const gdb_byte *regs = gregs;
	85	int i;
	86
	87	gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);
	88
	89	for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
	90	{
	91	if (regnum == i \|\| regnum == -1)
	92	regcache_raw_supply (regcache, i, regs + i * 8);
	93	}
	94
	95	if (regnum == ALPHA_PC_REGNUM \|\| regnum == -1)
	96	regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
	97	}
	98
	99	/* Supply register REGNUM from the buffer specified by GREGS and LEN
	100	in the general-purpose register set REGSET to register cache
	101	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	102
	103	static void
	104	alphanbsd_aout_supply_gregset (const struct regset *regset,
	105	struct regcache *regcache,
	106	int regnum, const void *gregs, size_t len)
	107	{
	108	const gdb_byte *regs = gregs;
	109	int i;
	110
	111	/* Table to map a GDB register number to a trapframe register index. */
8513dd2d JT	112	static const int regmap[] =
	113	{
	114	0, 1, 2, 3,
	115	4, 5, 6, 7,
	116	8, 9, 10, 11,
	117	12, 13, 14, 15,
	118	30, 31, 32, 16,
	119	17, 18, 19, 20,
	120	21, 22, 23, 24,
	121	25, 29, 26
	122	};
8513dd2d	123
3beabdb2	124	gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);
8513dd2d	125
3beabdb2	126	for (i = 0; i < ARRAY_SIZE(regmap); i++)
8513dd2d	127	{
3beabdb2 MK	128	if (regnum == i \|\| regnum == -1)
3beabdb2 MK	129	regcache_raw_supply (regcache, i, regs + regmap[i] * 8);
8513dd2d JT	130	}
8513dd2d JT	131
3beabdb2 MK	132	if (regnum == ALPHA_PC_REGNUM \|\| regnum == -1)
3beabdb2 MK	133	regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
8513dd2d	134
3beabdb2	135	if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
8513dd2d	136	{
3beabdb2 MK	137	regs += ALPHANBSD_SIZEOF_GREGS;
	138	len -= ALPHANBSD_SIZEOF_GREGS;
	139	alphanbsd_supply_fpregset (regset, regcache, regnum, regs, len);
8513dd2d JT	140	}
	141	}
	142
3beabdb2 MK	143	/* NetBSD/alpha register sets. */
	144
	145	static struct regset alphanbsd_gregset =
8513dd2d	146	{
3beabdb2 MK	147	NULL,
3beabdb2 MK	148	alphanbsd_supply_gregset
8513dd2d JT	149	};
8513dd2d JT	150
3beabdb2	151	static struct regset alphanbsd_fpregset =
8513dd2d	152	{
3beabdb2 MK	153	NULL,
3beabdb2 MK	154	alphanbsd_supply_fpregset
8513dd2d	155	};
da8ca43d	156
3beabdb2 MK	157	static struct regset alphanbsd_aout_gregset =
	158	{
	159	NULL,
	160	alphanbsd_aout_supply_gregset
	161	};
	162
	163	/* Return the appropriate register set for the core section identified
	164	by SECT_NAME and SECT_SIZE. */
	165
	166	static const struct regset *
	167	alphanbsd_regset_from_core_section (struct gdbarch *gdbarch,
	168	const char *sect_name, size_t sect_size)
	169	{
	170	if (strcmp (sect_name, ".reg") == 0 && sect_size >= ALPHANBSD_SIZEOF_GREGS)
	171	return &alphanbsd_gregset;
	172
	173	if (strcmp (sect_name, ".reg2") == 0 && sect_size >= ALPHANBSD_SIZEOF_FPREGS)
	174	return &alphanbsd_fpregset;
	175
	176	return NULL;
	177	}
	178
	179	static const struct regset *
	180	alphanbsd_aout_regset_from_core_section (struct gdbarch *gdbarch,
	181	const char *sect_name,
	182	size_t sect_size)
	183	{
	184	if (strcmp (sect_name, ".reg") == 0 && sect_size >= ALPHANBSD_SIZEOF_GREGS)
	185	return &alphanbsd_aout_gregset;
	186
	187	return NULL;
	188	}
	189	\f
	190
	191	/* Signal trampolines. */
	192
da8ca43d JT	193	/* Under NetBSD/alpha, signal handler invocations can be identified by the
	194	designated code sequence that is used to return from a signal handler.
	195	In particular, the return address of a signal handler points to the
	196	following code sequence:
	197
	198	ldq a0, 0(sp)
	199	lda sp, 16(sp)
	200	lda v0, 295(zero) # __sigreturn14
	201	call_pal callsys
	202
	203	Each instruction has a unique encoding, so we simply attempt to match
	204	the instruction the PC is pointing to with any of the above instructions.
	205	If there is a hit, we know the offset to the start of the designated
	206	sequence and can then check whether we really are executing in the
	207	signal trampoline. If not, -1 is returned, otherwise the offset from the
	208	start of the return sequence is returned. */
cfef91e4	209	static const unsigned char sigtramp_retcode[] =
da8ca43d	210	{
cfef91e4 JT	211	0x00, 0x00, 0x1e, 0xa6, /* ldq a0, 0(sp) */
	212	0x10, 0x00, 0xde, 0x23, /* lda sp, 16(sp) */
	213	0x27, 0x01, 0x1f, 0x20, /* lda v0, 295(zero) */
	214	0x83, 0x00, 0x00, 0x00, /* call_pal callsys */
da8ca43d	215	};
cfef91e4 JT	216	#define RETCODE_NWORDS 4
cfef91e4 JT	217	#define RETCODE_SIZE (RETCODE_NWORDS * 4)
da8ca43d JT	218
	219	LONGEST
	220	alphanbsd_sigtramp_offset (CORE_ADDR pc)
	221	{
cfef91e4	222	unsigned char ret[RETCODE_SIZE], w[4];
da8ca43d JT	223	LONGEST off;
	224	int i;
	225
1f602b35	226	if (deprecated_read_memory_nobpt (pc, (char *) w, 4) != 0)
da8ca43d JT	227	return -1;
	228
	229	for (i = 0; i < RETCODE_NWORDS; i++)
	230	{
cfef91e4	231	if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
da8ca43d JT	232	break;
	233	}
	234	if (i == RETCODE_NWORDS)
	235	return (-1);
	236
	237	off = i * 4;
	238	pc -= off;
	239
1f602b35	240	if (deprecated_read_memory_nobpt (pc, (char *) ret, sizeof (ret)) != 0)
da8ca43d JT	241	return -1;
da8ca43d JT	242
cfef91e4	243	if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
da8ca43d JT	244	return off;
	245
	246	return -1;
	247	}
	248
6c72f9f9 JT	249	static int
	250	alphanbsd_pc_in_sigtramp (CORE_ADDR pc, char *func_name)
	251	{
3d9b49b0 JT	252	return (nbsd_pc_in_sigtramp (pc, func_name)
3d9b49b0 JT	253	\|\| alphanbsd_sigtramp_offset (pc) >= 0);
6c72f9f9 JT	254	}
6c72f9f9 JT	255
2ca8ae21 JT	256	static CORE_ADDR
	257	alphanbsd_sigcontext_addr (struct frame_info *frame)
	258	{
	259	/* FIXME: This is not correct for all versions of NetBSD/alpha.
	260	We will probably need to disassemble the trampoline to figure
	261	out which trampoline frame type we have. */
f534e522	262	return get_frame_base (frame);
2ca8ae21 JT	263	}
2ca8ae21 JT	264
da8ca43d JT	265	static void
	266	alphanbsd_init_abi (struct gdbarch_info info,
	267	struct gdbarch *gdbarch)
	268	{
	269	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	270
baa490c4 RH	271	/* Hook into the DWARF CFI frame unwinder. */
	272	alpha_dwarf2_init_abi (info, gdbarch);
	273
	274	/* Hook into the MDEBUG frame unwinder. */
	275	alpha_mdebug_init_abi (info, gdbarch);
	276
da8ca43d JT	277	/* NetBSD/alpha does not provide single step support via ptrace(2); we
	278	must use software single-stepping. */
	279	set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);
	280
789f3b5f MK	281	/* NetBSD/alpha has SVR4-style shared libraries. */
	282	set_solib_svr4_fetch_link_map_offsets
	283	(gdbarch, svr4_lp64_fetch_link_map_offsets);
da8ca43d JT	284
da8ca43d JT	285	tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset;
f2524b93	286	tdep->pc_in_sigtramp = alphanbsd_pc_in_sigtramp;
2ca8ae21	287	tdep->sigcontext_addr = alphanbsd_sigcontext_addr;
accc6d1f JT	288
	289	tdep->jb_pc = 2;
	290	tdep->jb_elt_size = 8;
3beabdb2 MK	291
	292	set_gdbarch_regset_from_core_section
	293	(gdbarch, alphanbsd_regset_from_core_section);
	294	}
	295
	296	static void
	297	alphanbsd_aout_init_abi (struct gdbarch_info info,
	298	struct gdbarch *gdbarch)
	299	{
	300	alphanbsd_init_abi(info, gdbarch);
	301
	302	set_gdbarch_regset_from_core_section
	303	(gdbarch, alphanbsd_aout_regset_from_core_section);
da8ca43d	304	}
3beabdb2 MK	305	\f
	306
	307	static enum gdb_osabi
	308	alphanbsd_core_osabi_sniffer (bfd *abfd)
	309	{
	310	if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
	311	return GDB_OSABI_NETBSD_AOUT;
	312
	313	return GDB_OSABI_UNKNOWN;
	314	}
	315	\f
	316
	317	/* Provide a prototype to silence -Wmissing-prototypes. */
	318	void _initialize_alphanbsd_tdep (void);
da8ca43d JT	319
	320	void
	321	_initialize_alphanbsd_tdep (void)
	322	{
3beabdb2 MK	323	/* BFD doesn't set a flavour for NetBSD style a.out core files. */
	324	gdbarch_register_osabi_sniffer (bfd_arch_alpha, bfd_target_unknown_flavour,
	325	alphanbsd_core_osabi_sniffer);
	326
05816f70	327	gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_ELF,
70f80edf	328	alphanbsd_init_abi);
3beabdb2 MK	329	gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_AOUT,
3beabdb2 MK	330	alphanbsd_aout_init_abi);
e8d74ed3	331	gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_OPENBSD_ELF,
3beabdb2	332	alphanbsd_aout_init_abi);
da8ca43d	333	}