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

/* Target-dependent code for OpenBSD/hppa

   Copyright (C) 2004-2014 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 "osabi.h"
#include "regcache.h"
#include "regset.h"

#include "hppa-tdep.h"
#include "hppabsd-tdep.h"

/* Core file support.  */

/* Sizeof `struct reg' in <machine/reg.h>.  */
#define HPPAOBSD_SIZEOF_GREGS	(34 * 4) /* OpenBSD 5.1 and earlier.  */
#define HPPANBSD_SIZEOF_GREGS	(46 * 4) /* NetBSD and OpenBSD 5.2 and later.  */

/* Sizeof `struct fpreg' in <machine/reg.h>.  */
#define HPPAOBSD_SIZEOF_FPREGS	(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
hppaobsd_supply_gregset (const struct regset *regset,
			 struct regcache *regcache,
			 int regnum, const void *gregs, size_t len)
{
  gdb_byte zero[4] = { 0 };
  const gdb_byte *regs = gregs;
  size_t offset;
  int i;

  gdb_assert (len >= HPPAOBSD_SIZEOF_GREGS);

  if (regnum == -1 || regnum == HPPA_R0_REGNUM)
    regcache_raw_supply (regcache, HPPA_R0_REGNUM, &zero);
  for (i = HPPA_R1_REGNUM, offset = 4; i <= HPPA_R31_REGNUM; i++, offset += 4)
    {
      if (regnum == -1 || regnum == i)
	regcache_raw_supply (regcache, i, regs + offset);
    }

  if (len >= HPPANBSD_SIZEOF_GREGS)
    {
      if (regnum == -1 || regnum == HPPA_IPSW_REGNUM)
	regcache_raw_supply (regcache, HPPA_IPSW_REGNUM, regs);
      if (regnum == -1 || regnum == HPPA_SAR_REGNUM)
	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs + 32 * 4);
      if (regnum == -1 || regnum == HPPA_PCSQ_HEAD_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
      if (regnum == -1 || regnum == HPPA_PCSQ_TAIL_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
      if (regnum == -1 || regnum == HPPA_PCOQ_HEAD_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
      if (regnum == -1 || regnum == HPPA_PCOQ_TAIL_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
      if (regnum == -1 || regnum == HPPA_SR0_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR0_REGNUM, regs + 37 * 4);
      if (regnum == -1 || regnum == HPPA_SR1_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR1_REGNUM, regs + 38 * 4);
      if (regnum == -1 || regnum == HPPA_SR2_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR2_REGNUM, regs + 39 * 4);
      if (regnum == -1 || regnum == HPPA_SR3_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR3_REGNUM, regs + 40 * 4);
      if (regnum == -1 || regnum == HPPA_SR4_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR4_REGNUM, regs + 41 * 4);
      if (regnum == -1 || regnum == HPPA_SR5_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR5_REGNUM, regs + 42 * 4);
      if (regnum == -1 || regnum == HPPA_SR6_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR6_REGNUM, regs + 43 * 4);
      if (regnum == -1 || regnum == HPPA_SR7_REGNUM)
	regcache_raw_supply (regcache, HPPA_SR7_REGNUM, regs + 44 * 4);
      if (regnum == -1 || regnum == HPPA_CR26_REGNUM)
	regcache_raw_supply (regcache, HPPA_CR26_REGNUM, regs + 45 * 4);
      if (regnum == -1 || regnum == HPPA_CR27_REGNUM)
	regcache_raw_supply (regcache, HPPA_CR27_REGNUM, regs + 46 * 4);
    }
  else
    {
      if (regnum == -1 || regnum == HPPA_SAR_REGNUM)
	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs);
      if (regnum == -1 || regnum == HPPA_PCOQ_HEAD_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
      if (regnum == -1 || regnum == HPPA_PCOQ_TAIL_REGNUM)
	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
    }
}

/* 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
hppaobsd_supply_fpregset (const struct regset *regset,
			  struct regcache *regcache,
			  int regnum, const void *fpregs, size_t len)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  const gdb_byte *regs = fpregs;
  int i;

  gdb_assert (len >= HPPAOBSD_SIZEOF_FPREGS);

  for (i = HPPA_FP0_REGNUM; i <= HPPA_FP31R_REGNUM; i++)
    {
      if (regnum == i || regnum == -1)
	regcache_raw_supply (regcache, i, regs + (i - HPPA_FP0_REGNUM) * 4);
    }
}

/* OpenBSD/hppa register sets.  */

static const struct regset hppaobsd_gregset =
{
  NULL,
  hppaobsd_supply_gregset
};

static const struct regset hppaobsd_fpregset =
{
  NULL,
  hppaobsd_supply_fpregset
};

/* Iterate over supported core file register note sections. */

static void
hppaobsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
				       iterate_over_regset_sections_cb *cb,
				       void *cb_data,
				       const struct regcache *regcache)
{
  cb (".reg", HPPAOBSD_SIZEOF_GREGS, &hppaobsd_gregset, NULL, cb_data);
  cb (".reg2", HPPAOBSD_SIZEOF_FPREGS, &hppaobsd_fpregset, NULL, cb_data);
}
\f

static void
hppaobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  /* Obviously OpenBSD is BSD-based.  */
  hppabsd_init_abi (info, gdbarch);

  /* Core file support.  */
  set_gdbarch_iterate_over_regset_sections
    (gdbarch, hppaobsd_iterate_over_regset_sections);
}
\f

/* OpenBSD uses uses the traditional NetBSD core file format, even for
   ports that use ELF.  */
#define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF

static enum gdb_osabi
hppaobsd_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_hppabsd_tdep (void);

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

  gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_OPENBSD_ELF,
			  hppaobsd_init_abi);
}
Commit	Line	Data
af5ca30d NH	1	/* Target-dependent code for OpenBSD/hppa
af5ca30d NH	2
ecd75fc8	3	Copyright (C) 2004-2014 Free Software Foundation, Inc.
af5ca30d NH	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
5b1ba0e5	9	the Free Software Foundation; either version 3 of the License, or
af5ca30d NH	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
5b1ba0e5	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
af5ca30d NH	19
	20	#include "defs.h"
	21	#include "osabi.h"
	22	#include "regcache.h"
	23	#include "regset.h"
	24
af5ca30d	25	#include "hppa-tdep.h"
63807e1d	26	#include "hppabsd-tdep.h"
af5ca30d NH	27
	28	/* Core file support. */
	29
	30	/* Sizeof `struct reg' in <machine/reg.h>. */
cbb6aada MK	31	#define HPPAOBSD_SIZEOF_GREGS (34 * 4) /* OpenBSD 5.1 and earlier. */
cbb6aada MK	32	#define HPPANBSD_SIZEOF_GREGS (46 * 4) /* NetBSD and OpenBSD 5.2 and later. */
7c54a108 MK	33
	34	/* Sizeof `struct fpreg' in <machine/reg.h>. */
	35	#define HPPAOBSD_SIZEOF_FPREGS (32 * 8)
af5ca30d NH	36
	37	/* Supply register REGNUM from the buffer specified by GREGS and LEN
	38	in the general-purpose register set REGSET to register cache
	39	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	40
	41	static void
7c54a108 MK	42	hppaobsd_supply_gregset (const struct regset *regset,
	43	struct regcache *regcache,
	44	int regnum, const void *gregs, size_t len)
af5ca30d	45	{
cbb6aada	46	gdb_byte zero[4] = { 0 };
af5ca30d NH	47	const gdb_byte *regs = gregs;
	48	size_t offset;
	49	int i;
	50
7c54a108	51	gdb_assert (len >= HPPAOBSD_SIZEOF_GREGS);
af5ca30d	52
cbb6aada MK	53	if (regnum == -1 \|\| regnum == HPPA_R0_REGNUM)
cbb6aada MK	54	regcache_raw_supply (regcache, HPPA_R0_REGNUM, &zero);
af5ca30d NH	55	for (i = HPPA_R1_REGNUM, offset = 4; i <= HPPA_R31_REGNUM; i++, offset += 4)
	56	{
	57	if (regnum == -1 \|\| regnum == i)
	58	regcache_raw_supply (regcache, i, regs + offset);
	59	}
	60
cbb6aada MK	61	if (len >= HPPANBSD_SIZEOF_GREGS)
	62	{
	63	if (regnum == -1 \|\| regnum == HPPA_IPSW_REGNUM)
	64	regcache_raw_supply (regcache, HPPA_IPSW_REGNUM, regs);
	65	if (regnum == -1 \|\| regnum == HPPA_SAR_REGNUM)
	66	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs + 32 * 4);
	67	if (regnum == -1 \|\| regnum == HPPA_PCSQ_HEAD_REGNUM)
	68	regcache_raw_supply (regcache, HPPA_PCSQ_HEAD_REGNUM, regs + 33 * 4);
	69	if (regnum == -1 \|\| regnum == HPPA_PCSQ_TAIL_REGNUM)
	70	regcache_raw_supply (regcache, HPPA_PCSQ_TAIL_REGNUM, regs + 34 * 4);
	71	if (regnum == -1 \|\| regnum == HPPA_PCOQ_HEAD_REGNUM)
	72	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 35 * 4);
	73	if (regnum == -1 \|\| regnum == HPPA_PCOQ_TAIL_REGNUM)
	74	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 36 * 4);
	75	if (regnum == -1 \|\| regnum == HPPA_SR0_REGNUM)
	76	regcache_raw_supply (regcache, HPPA_SR0_REGNUM, regs + 37 * 4);
	77	if (regnum == -1 \|\| regnum == HPPA_SR1_REGNUM)
	78	regcache_raw_supply (regcache, HPPA_SR1_REGNUM, regs + 38 * 4);
	79	if (regnum == -1 \|\| regnum == HPPA_SR2_REGNUM)
	80	regcache_raw_supply (regcache, HPPA_SR2_REGNUM, regs + 39 * 4);
	81	if (regnum == -1 \|\| regnum == HPPA_SR3_REGNUM)
	82	regcache_raw_supply (regcache, HPPA_SR3_REGNUM, regs + 40 * 4);
	83	if (regnum == -1 \|\| regnum == HPPA_SR4_REGNUM)
	84	regcache_raw_supply (regcache, HPPA_SR4_REGNUM, regs + 41 * 4);
	85	if (regnum == -1 \|\| regnum == HPPA_SR5_REGNUM)
	86	regcache_raw_supply (regcache, HPPA_SR5_REGNUM, regs + 42 * 4);
	87	if (regnum == -1 \|\| regnum == HPPA_SR6_REGNUM)
	88	regcache_raw_supply (regcache, HPPA_SR6_REGNUM, regs + 43 * 4);
	89	if (regnum == -1 \|\| regnum == HPPA_SR7_REGNUM)
	90	regcache_raw_supply (regcache, HPPA_SR7_REGNUM, regs + 44 * 4);
	91	if (regnum == -1 \|\| regnum == HPPA_CR26_REGNUM)
	92	regcache_raw_supply (regcache, HPPA_CR26_REGNUM, regs + 45 * 4);
	93	if (regnum == -1 \|\| regnum == HPPA_CR27_REGNUM)
	94	regcache_raw_supply (regcache, HPPA_CR27_REGNUM, regs + 46 * 4);
	95	}
	96	else
	97	{
	98	if (regnum == -1 \|\| regnum == HPPA_SAR_REGNUM)
	99	regcache_raw_supply (regcache, HPPA_SAR_REGNUM, regs);
	100	if (regnum == -1 \|\| regnum == HPPA_PCOQ_HEAD_REGNUM)
	101	regcache_raw_supply (regcache, HPPA_PCOQ_HEAD_REGNUM, regs + 32 * 4);
	102	if (regnum == -1 \|\| regnum == HPPA_PCOQ_TAIL_REGNUM)
	103	regcache_raw_supply (regcache, HPPA_PCOQ_TAIL_REGNUM, regs + 33 * 4);
	104	}
af5ca30d NH	105	}
af5ca30d NH	106
7c54a108 MK	107	/* Supply register REGNUM from the buffer specified by FPREGS and LEN
	108	in the floating-point register set REGSET to register cache
	109	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	110
	111	static void
	112	hppaobsd_supply_fpregset (const struct regset *regset,
	113	struct regcache *regcache,
	114	int regnum, const void *fpregs, size_t len)
	115	{
	116	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	117	const gdb_byte *regs = fpregs;
	118	int i;
	119
	120	gdb_assert (len >= HPPAOBSD_SIZEOF_FPREGS);
	121
	122	for (i = HPPA_FP0_REGNUM; i <= HPPA_FP31R_REGNUM; i++)
	123	{
	124	if (regnum == i \|\| regnum == -1)
	125	regcache_raw_supply (regcache, i, regs + (i - HPPA_FP0_REGNUM) * 4);
	126	}
	127	}
	128
	129	/* OpenBSD/hppa register sets. */
af5ca30d	130
3ca7dae4	131	static const struct regset hppaobsd_gregset =
af5ca30d NH	132	{
af5ca30d NH	133	NULL,
7c54a108 MK	134	hppaobsd_supply_gregset
	135	};
	136
3ca7dae4	137	static const struct regset hppaobsd_fpregset =
7c54a108 MK	138	{
	139	NULL,
	140	hppaobsd_supply_fpregset
af5ca30d NH	141	};
af5ca30d NH	142
50c5eb53	143	/* Iterate over supported core file register note sections. */
af5ca30d	144
50c5eb53 AA	145	static void
	146	hppaobsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
	147	iterate_over_regset_sections_cb *cb,
	148	void *cb_data,
	149	const struct regcache *regcache)
af5ca30d	150	{
50c5eb53 AA	151	cb (".reg", HPPAOBSD_SIZEOF_GREGS, &hppaobsd_gregset, NULL, cb_data);
50c5eb53 AA	152	cb (".reg2", HPPAOBSD_SIZEOF_FPREGS, &hppaobsd_fpregset, NULL, cb_data);
af5ca30d NH	153	}
	154	\f
	155
63807e1d	156	static void
af5ca30d NH	157	hppaobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	158	{
	159	/* Obviously OpenBSD is BSD-based. */
	160	hppabsd_init_abi (info, gdbarch);
	161
	162	/* Core file support. */
50c5eb53 AA	163	set_gdbarch_iterate_over_regset_sections
50c5eb53 AA	164	(gdbarch, hppaobsd_iterate_over_regset_sections);
af5ca30d NH	165	}
	166	\f
	167
	168	/* OpenBSD uses uses the traditional NetBSD core file format, even for
	169	ports that use ELF. */
	170	#define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
	171
	172	static enum gdb_osabi
	173	hppaobsd_core_osabi_sniffer (bfd *abfd)
	174	{
	175	if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
	176	return GDB_OSABI_NETBSD_CORE;
	177
	178	return GDB_OSABI_UNKNOWN;
	179	}
	180	\f
	181
	182	/* Provide a prototype to silence -Wmissing-prototypes. */
	183	void _initialize_hppabsd_tdep (void);
	184
	185	void
	186	_initialize_hppabsd_tdep (void)
	187	{
	188	/* BFD doesn't set a flavour for NetBSD style a.out core files. */
	189	gdbarch_register_osabi_sniffer (bfd_arch_hppa, bfd_target_unknown_flavour,
	190	hppaobsd_core_osabi_sniffer);
	191
	192	gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_OPENBSD_ELF,
	193	hppaobsd_init_abi);
	194	}