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

/* Target-dependent code for OpenBSD/hppa

   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 "osabi.h"
#include "regcache.h"
#include "regset.h"

#include "hppa-tdep.h"
#include "hppa-bsd-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 = (const gdb_byte *) 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)
{
  const gdb_byte *regs = (const gdb_byte *) 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,
  NULL,
  REGSET_VARIABLE_SIZE
};

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);
}

void
_initialize_hppabsd_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_OPENBSD,
			  hppaobsd_init_abi);
}
Commit	Line	Data
af5ca30d NH	1	/* Target-dependent code for OpenBSD/hppa
af5ca30d NH	2
e2882c85	3	Copyright (C) 2004-2018 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"
03b62bbb	26	#include "hppa-bsd-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 };
9a3c8263	47	const gdb_byte regs = (const gdb_byte ) gregs;
af5ca30d NH	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	{
9a3c8263	116	const gdb_byte regs = (const gdb_byte ) fpregs;
7c54a108 MK	117	int i;
	118
	119	gdb_assert (len >= HPPAOBSD_SIZEOF_FPREGS);
	120
	121	for (i = HPPA_FP0_REGNUM; i <= HPPA_FP31R_REGNUM; i++)
	122	{
	123	if (regnum == i \|\| regnum == -1)
	124	regcache_raw_supply (regcache, i, regs + (i - HPPA_FP0_REGNUM) * 4);
	125	}
	126	}
	127
	128	/* OpenBSD/hppa register sets. */
af5ca30d	129
3ca7dae4	130	static const struct regset hppaobsd_gregset =
af5ca30d NH	131	{
af5ca30d NH	132	NULL,
f962539a AA	133	hppaobsd_supply_gregset,
	134	NULL,
	135	REGSET_VARIABLE_SIZE
7c54a108 MK	136	};
7c54a108 MK	137
3ca7dae4	138	static const struct regset hppaobsd_fpregset =
7c54a108 MK	139	{
	140	NULL,
	141	hppaobsd_supply_fpregset
af5ca30d NH	142	};
af5ca30d NH	143
50c5eb53	144	/* Iterate over supported core file register note sections. */
af5ca30d	145
50c5eb53 AA	146	static void
	147	hppaobsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
	148	iterate_over_regset_sections_cb *cb,
	149	void *cb_data,
	150	const struct regcache *regcache)
af5ca30d	151	{
50c5eb53 AA	152	cb (".reg", HPPAOBSD_SIZEOF_GREGS, &hppaobsd_gregset, NULL, cb_data);
50c5eb53 AA	153	cb (".reg2", HPPAOBSD_SIZEOF_FPREGS, &hppaobsd_fpregset, NULL, cb_data);
af5ca30d NH	154	}
	155	\f
	156
63807e1d	157	static void
af5ca30d NH	158	hppaobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	159	{
	160	/* Obviously OpenBSD is BSD-based. */
	161	hppabsd_init_abi (info, gdbarch);
	162
	163	/* Core file support. */
50c5eb53 AA	164	set_gdbarch_iterate_over_regset_sections
50c5eb53 AA	165	(gdbarch, hppaobsd_iterate_over_regset_sections);
af5ca30d	166	}
af5ca30d NH	167
	168	void
	169	_initialize_hppabsd_tdep (void)
	170	{
1736a7bd	171	gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_OPENBSD,
af5ca30d NH	172	hppaobsd_init_abi);
af5ca30d NH	173	}