[deliverable/binutils-gdb.git] / gdb / mips-fbsd-tdep.c

/* Target-dependent code for FreeBSD/mips.

   Copyright (C) 2017 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 "regset.h"
#include "trad-frame.h"
#include "tramp-frame.h"

#include "fbsd-tdep.h"
#include "mips-tdep.h"
#include "mips-fbsd-tdep.h"

#include "solib-svr4.h"

/* Core file support. */

/* Number of registers in `struct reg' from <machine/reg.h>.  The
   first 38 follow the standard MIPS layout.  The 39th holds
   IC_INT_REG on RM7K and RM9K processors.  The 40th is a dummy for
   padding.  */
#define MIPS_FBSD_NUM_GREGS	40

/* Number of registers in `struct fpreg' from <machine/reg.h>.  The
   first 32 hold floating point registers.  33 holds the FSR.  The
   34th is a dummy for padding.  */
#define MIPS_FBSD_NUM_FPREGS	34

/* Supply a single register.  The register size might not match, so use
   regcache->raw_supply_integer ().  */

static void
mips_fbsd_supply_reg (struct regcache *regcache, int regnum, const void *addr,
		      size_t len)
{
  regcache->raw_supply_integer (regnum, (const gdb_byte *) addr, len, true);
}

/* Collect a single register.  The register size might not match, so use
   regcache->raw_collect_integer ().  */

static void
mips_fbsd_collect_reg (const struct regcache *regcache, int regnum, void *addr,
		       size_t len)
{
  regcache->raw_collect_integer (regnum, (gdb_byte *) addr, len, true);
}

/* Supply the floating-point registers stored in FPREGS to REGCACHE.
   Each floating-point register in FPREGS is REGSIZE bytes in
   length.  */

void
mips_fbsd_supply_fpregs (struct regcache *regcache, int regnum,
			 const void *fpregs, size_t regsize)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  const gdb_byte *regs = (const gdb_byte *) fpregs;
  int i, fp0num, fsrnum;

  fp0num = mips_regnum (gdbarch)->fp0;
  fsrnum = mips_regnum (gdbarch)->fp_control_status;
  for (i = fp0num; i <= fsrnum; i++)
    if (regnum == i || regnum == -1)
      mips_fbsd_supply_reg (regcache, i,
			    regs + (i - fp0num) * regsize, regsize);
}

/* Supply the general-purpose registers stored in GREGS to REGCACHE.
   Each general-purpose register in GREGS is REGSIZE bytes in
   length.  */

void
mips_fbsd_supply_gregs (struct regcache *regcache, int regnum,
			const void *gregs, size_t regsize)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  const gdb_byte *regs = (const gdb_byte *) gregs;
  int i;

  for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
    if (regnum == i || regnum == -1)
      mips_fbsd_supply_reg (regcache, i, regs + i * regsize, regsize);
}

/* Collect the floating-point registers from REGCACHE and store them
   in FPREGS.  Each floating-point register in FPREGS is REGSIZE bytes
   in length.  */

void
mips_fbsd_collect_fpregs (const struct regcache *regcache, int regnum,
			  void *fpregs, size_t regsize)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  gdb_byte *regs = (gdb_byte *) fpregs;
  int i, fp0num, fsrnum;

  fp0num = mips_regnum (gdbarch)->fp0;
  fsrnum = mips_regnum (gdbarch)->fp_control_status;
  for (i = fp0num; i <= fsrnum; i++)
    if (regnum == i || regnum == -1)
      mips_fbsd_collect_reg (regcache, i,
			     regs + (i - fp0num) * regsize, regsize);
}

/* Collect the general-purpose registers from REGCACHE and store them
   in GREGS.  Each general-purpose register in GREGS is REGSIZE bytes
   in length.  */

void
mips_fbsd_collect_gregs (const struct regcache *regcache, int regnum,
			 void *gregs, size_t regsize)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  gdb_byte *regs = (gdb_byte *) gregs;
  int i;

  for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
    if (regnum == i || regnum == -1)
      mips_fbsd_collect_reg (regcache, i, regs + i * regsize, regsize);
}

/* 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
mips_fbsd_supply_fpregset (const struct regset *regset,
			   struct regcache *regcache,
			   int regnum, const void *fpregs, size_t len)
{
  size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));

  gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);

  mips_fbsd_supply_fpregs (regcache, regnum, fpregs, regsize);
}

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

static void
mips_fbsd_collect_fpregset (const struct regset *regset,
			    const struct regcache *regcache,
			    int regnum, void *fpregs, size_t len)
{
  size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));

  gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);

  mips_fbsd_collect_fpregs (regcache, regnum, fpregs, regsize);
}

/* 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
mips_fbsd_supply_gregset (const struct regset *regset,
			  struct regcache *regcache, int regnum,
			  const void *gregs, size_t len)
{
  size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));

  gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);

  mips_fbsd_supply_gregs (regcache, regnum, gregs, regsize);
}

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

static void
mips_fbsd_collect_gregset (const struct regset *regset,
			   const struct regcache *regcache,
			   int regnum, void *gregs, size_t len)
{
  size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));

  gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);

  mips_fbsd_collect_gregs (regcache, regnum, gregs, regsize);
}

/* FreeBSD/mips register sets.  */

static const struct regset mips_fbsd_gregset =
{
  NULL,
  mips_fbsd_supply_gregset,
  mips_fbsd_collect_gregset,
};

static const struct regset mips_fbsd_fpregset =
{
  NULL,
  mips_fbsd_supply_fpregset,
  mips_fbsd_collect_fpregset,
};

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

static void
mips_fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
					iterate_over_regset_sections_cb *cb,
					void *cb_data,
					const struct regcache *regcache)
{
  size_t regsize = mips_abi_regsize (gdbarch);

  cb (".reg", MIPS_FBSD_NUM_GREGS * regsize, &mips_fbsd_gregset,
      NULL, cb_data);
  cb (".reg2", MIPS_FBSD_NUM_FPREGS * regsize, &mips_fbsd_fpregset,
      NULL, cb_data);
}

/* Signal trampoline support.  */

#define FBSD_SYS_sigreturn	417

#define MIPS_INST_LI_V0_SIGRETURN 0x24020000 + FBSD_SYS_sigreturn
#define MIPS_INST_SYSCALL	0x0000000c
#define MIPS_INST_BREAK		0x0000000d

#define O32_SIGFRAME_UCONTEXT_OFFSET	(16)
#define O32_SIGSET_T_SIZE	(16)

#define O32_UCONTEXT_ONSTACK	(O32_SIGSET_T_SIZE)
#define O32_UCONTEXT_PC		(O32_UCONTEXT_ONSTACK + 4)
#define O32_UCONTEXT_REGS	(O32_UCONTEXT_PC + 4)
#define O32_UCONTEXT_SR		(O32_UCONTEXT_REGS + 4 * 32)
#define O32_UCONTEXT_LO		(O32_UCONTEXT_SR + 4)
#define O32_UCONTEXT_HI		(O32_UCONTEXT_LO + 4)
#define O32_UCONTEXT_FPUSED	(O32_UCONTEXT_HI + 4)
#define O32_UCONTEXT_FPREGS	(O32_UCONTEXT_FPUSED + 4)

#define O32_UCONTEXT_REG_SIZE	4

static void
mips_fbsd_sigframe_init (const struct tramp_frame *self,
			 struct frame_info *this_frame,
			 struct trad_frame_cache *cache,
			 CORE_ADDR func)
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  CORE_ADDR sp, ucontext_addr, addr;
  int regnum;
  gdb_byte buf[4];

  /* We find the appropriate instance of `ucontext_t' at a
     fixed offset in the signal frame.  */
  sp = get_frame_register_signed (this_frame,
				  MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
  ucontext_addr = sp + O32_SIGFRAME_UCONTEXT_OFFSET;

  /* PC.  */
  regnum = mips_regnum (gdbarch)->pc;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + O32_UCONTEXT_PC);

  /* GPRs.  */
  for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + O32_UCONTEXT_REGS;
       regnum <= MIPS_RA_REGNUM; regnum++, addr += O32_UCONTEXT_REG_SIZE)
    trad_frame_set_reg_addr (cache,
			     regnum + gdbarch_num_regs (gdbarch),
			     addr);

  regnum = MIPS_PS_REGNUM;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + O32_UCONTEXT_SR);

  /* HI and LO.  */
  regnum = mips_regnum (gdbarch)->lo;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + O32_UCONTEXT_LO);
  regnum = mips_regnum (gdbarch)->hi;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + O32_UCONTEXT_HI);

  if (target_read_memory (ucontext_addr + O32_UCONTEXT_FPUSED, buf, 4) == 0
      && extract_unsigned_integer (buf, 4, byte_order) != 0)
    {
      for (regnum = 0, addr = ucontext_addr + O32_UCONTEXT_FPREGS;
	   regnum < 32; regnum++, addr += O32_UCONTEXT_REG_SIZE)
	trad_frame_set_reg_addr (cache,
				 regnum + gdbarch_fp0_regnum (gdbarch),
				 addr);
      trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
			       addr);
    }

  trad_frame_set_id (cache, frame_id_build (sp, func));
}

#define MIPS_INST_ADDIU_A0_SP_O32 (0x27a40000 \
				   + O32_SIGFRAME_UCONTEXT_OFFSET)

static const struct tramp_frame mips_fbsd_sigframe =
{
  SIGTRAMP_FRAME,
  MIPS_INSN32_SIZE,
  {
    { MIPS_INST_ADDIU_A0_SP_O32, -1 },	/* addiu   a0, sp, SIGF_UC */
    { MIPS_INST_LI_V0_SIGRETURN, -1 },	/* li      v0, SYS_sigreturn */
    { MIPS_INST_SYSCALL, -1 },		/* syscall */
    { MIPS_INST_BREAK, -1 },		/* break */
    { TRAMP_SENTINEL_INSN, -1 }
  },
  mips_fbsd_sigframe_init
};

#define N64_SIGFRAME_UCONTEXT_OFFSET	(32)
#define N64_SIGSET_T_SIZE	(16)

#define N64_UCONTEXT_ONSTACK	(N64_SIGSET_T_SIZE)
#define N64_UCONTEXT_PC		(N64_UCONTEXT_ONSTACK + 8)
#define N64_UCONTEXT_REGS	(N64_UCONTEXT_PC + 8)
#define N64_UCONTEXT_SR		(N64_UCONTEXT_REGS + 8 * 32)
#define N64_UCONTEXT_LO		(N64_UCONTEXT_SR + 8)
#define N64_UCONTEXT_HI		(N64_UCONTEXT_LO + 8)
#define N64_UCONTEXT_FPUSED	(N64_UCONTEXT_HI + 8)
#define N64_UCONTEXT_FPREGS	(N64_UCONTEXT_FPUSED + 8)

#define N64_UCONTEXT_REG_SIZE	8

static void
mips64_fbsd_sigframe_init (const struct tramp_frame *self,
			   struct frame_info *this_frame,
			   struct trad_frame_cache *cache,
			   CORE_ADDR func)
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  CORE_ADDR sp, ucontext_addr, addr;
  int regnum;
  gdb_byte buf[4];

  /* We find the appropriate instance of `ucontext_t' at a
     fixed offset in the signal frame.  */
  sp = get_frame_register_signed (this_frame,
				  MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
  ucontext_addr = sp + N64_SIGFRAME_UCONTEXT_OFFSET;

  /* PC.  */
  regnum = mips_regnum (gdbarch)->pc;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + N64_UCONTEXT_PC);

  /* GPRs.  */
  for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + N64_UCONTEXT_REGS;
       regnum <= MIPS_RA_REGNUM; regnum++, addr += N64_UCONTEXT_REG_SIZE)
    trad_frame_set_reg_addr (cache,
			     regnum + gdbarch_num_regs (gdbarch),
			     addr);

  regnum = MIPS_PS_REGNUM;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + N64_UCONTEXT_SR);

  /* HI and LO.  */
  regnum = mips_regnum (gdbarch)->lo;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + N64_UCONTEXT_LO);
  regnum = mips_regnum (gdbarch)->hi;
  trad_frame_set_reg_addr (cache,
			   regnum + gdbarch_num_regs (gdbarch),
			   ucontext_addr + N64_UCONTEXT_HI);

  if (target_read_memory (ucontext_addr + N64_UCONTEXT_FPUSED, buf, 4) == 0
      && extract_unsigned_integer (buf, 4, byte_order) != 0)
    {
      for (regnum = 0, addr = ucontext_addr + N64_UCONTEXT_FPREGS;
	   regnum < 32; regnum++, addr += N64_UCONTEXT_REG_SIZE)
	trad_frame_set_reg_addr (cache,
				 regnum + gdbarch_fp0_regnum (gdbarch),
				 addr);
      trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
			       addr);
    }

  trad_frame_set_id (cache, frame_id_build (sp, func));
}

#define MIPS_INST_DADDIU_A0_SP_N64 (0x67a40000 \
				    + N64_SIGFRAME_UCONTEXT_OFFSET)

static const struct tramp_frame mips64_fbsd_sigframe =
{
  SIGTRAMP_FRAME,
  MIPS_INSN32_SIZE,
  {
    { MIPS_INST_DADDIU_A0_SP_N64, -1 },	/* daddiu  a0, sp, SIGF_UC */
    { MIPS_INST_LI_V0_SIGRETURN, -1 },	/* li      v0, SYS_sigreturn */
    { MIPS_INST_SYSCALL, -1 },		/* syscall */
    { MIPS_INST_BREAK, -1 },		/* break */
    { TRAMP_SENTINEL_INSN, -1 }
  },
  mips64_fbsd_sigframe_init
};

/* Shared library support.  */

/* FreeBSD/mips uses a slightly different `struct link_map' than the
   other FreeBSD platforms as it includes an additional `l_off'
   member.  */

static struct link_map_offsets *
mips_fbsd_ilp32_fetch_link_map_offsets (void)
{
  static struct link_map_offsets lmo;
  static struct link_map_offsets *lmp = NULL;

  if (lmp == NULL)
    {
      lmp = &lmo;

      lmo.r_version_offset = 0;
      lmo.r_version_size = 4;
      lmo.r_map_offset = 4;
      lmo.r_brk_offset = 8;
      lmo.r_ldsomap_offset = -1;

      lmo.link_map_size = 24;
      lmo.l_addr_offset = 0;
      lmo.l_name_offset = 8;
      lmo.l_ld_offset = 12;
      lmo.l_next_offset = 16;
      lmo.l_prev_offset = 20;
    }

  return lmp;
}

static struct link_map_offsets *
mips_fbsd_lp64_fetch_link_map_offsets (void)
{
  static struct link_map_offsets lmo;
  static struct link_map_offsets *lmp = NULL;

  if (lmp == NULL)
    {
      lmp = &lmo;

      lmo.r_version_offset = 0;
      lmo.r_version_size = 4;
      lmo.r_map_offset = 8;
      lmo.r_brk_offset = 16;
      lmo.r_ldsomap_offset = -1;

      lmo.link_map_size = 48;
      lmo.l_addr_offset = 0;
      lmo.l_name_offset = 16;
      lmo.l_ld_offset = 24;
      lmo.l_next_offset = 32;
      lmo.l_prev_offset = 40;
    }

  return lmp;
}

static void
mips_fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  enum mips_abi abi = mips_abi (gdbarch);

  /* Generic FreeBSD support.  */
  fbsd_init_abi (info, gdbarch);

  set_gdbarch_software_single_step (gdbarch, mips_software_single_step);

  switch (abi)
    {
      case MIPS_ABI_O32:
	tramp_frame_prepend_unwinder (gdbarch, &mips_fbsd_sigframe);
	break;
      case MIPS_ABI_N32:
	break;
      case MIPS_ABI_N64:
	tramp_frame_prepend_unwinder (gdbarch, &mips64_fbsd_sigframe);
	break;
    }

  set_gdbarch_iterate_over_regset_sections
    (gdbarch, mips_fbsd_iterate_over_regset_sections);

  /* FreeBSD/mips has SVR4-style shared libraries.  */
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, (gdbarch_ptr_bit (gdbarch) == 32 ?
	       mips_fbsd_ilp32_fetch_link_map_offsets :
	       mips_fbsd_lp64_fetch_link_map_offsets));
}
\f

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

void
_initialize_mips_fbsd_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_FREEBSD,
			  mips_fbsd_init_abi);
}
Commit	Line	Data
387360da JB	1	/* Target-dependent code for FreeBSD/mips.
	2
	3	Copyright (C) 2017 Free Software Foundation, Inc.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	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
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
	21	#include "osabi.h"
	22	#include "regset.h"
	23	#include "trad-frame.h"
	24	#include "tramp-frame.h"
	25
	26	#include "fbsd-tdep.h"
	27	#include "mips-tdep.h"
	28	#include "mips-fbsd-tdep.h"
	29
	30	#include "solib-svr4.h"
	31
387360da JB	32	/* Core file support. */
	33
	34	/* Number of registers in `struct reg' from <machine/reg.h>. The
	35	first 38 follow the standard MIPS layout. The 39th holds
	36	IC_INT_REG on RM7K and RM9K processors. The 40th is a dummy for
	37	padding. */
	38	#define MIPS_FBSD_NUM_GREGS 40
	39
	40	/* Number of registers in `struct fpreg' from <machine/reg.h>. The
	41	first 32 hold floating point registers. 33 holds the FSR. The
	42	34th is a dummy for padding. */
	43	#define MIPS_FBSD_NUM_FPREGS 34
	44
b057297a AH	45	/* Supply a single register. The register size might not match, so use
b057297a AH	46	regcache->raw_supply_integer (). */
387360da JB	47
	48	static void
	49	mips_fbsd_supply_reg (struct regcache regcache, int regnum, const void addr,
	50	size_t len)
	51	{
b057297a	52	regcache->raw_supply_integer (regnum, (const gdb_byte *) addr, len, true);
387360da JB	53	}
387360da JB	54
b057297a AH	55	/* Collect a single register. The register size might not match, so use
b057297a AH	56	regcache->raw_collect_integer (). */
387360da JB	57
	58	static void
	59	mips_fbsd_collect_reg (const struct regcache regcache, int regnum, void addr,
	60	size_t len)
	61	{
b057297a	62	regcache->raw_collect_integer (regnum, (gdb_byte *) addr, len, true);
387360da JB	63	}
	64
	65	/* Supply the floating-point registers stored in FPREGS to REGCACHE.
	66	Each floating-point register in FPREGS is REGSIZE bytes in
	67	length. */
	68
	69	void
	70	mips_fbsd_supply_fpregs (struct regcache *regcache, int regnum,
	71	const void *fpregs, size_t regsize)
	72	{
f7241d4f	73	struct gdbarch *gdbarch = get_regcache_arch (regcache);
387360da	74	const gdb_byte regs = (const gdb_byte ) fpregs;
f7241d4f	75	int i, fp0num, fsrnum;
387360da	76
f7241d4f JB	77	fp0num = mips_regnum (gdbarch)->fp0;
	78	fsrnum = mips_regnum (gdbarch)->fp_control_status;
	79	for (i = fp0num; i <= fsrnum; i++)
387360da JB	80	if (regnum == i \|\| regnum == -1)
387360da JB	81	mips_fbsd_supply_reg (regcache, i,
f7241d4f	82	regs + (i - fp0num) * regsize, regsize);
387360da JB	83	}
	84
	85	/* Supply the general-purpose registers stored in GREGS to REGCACHE.
	86	Each general-purpose register in GREGS is REGSIZE bytes in
	87	length. */
	88
	89	void
	90	mips_fbsd_supply_gregs (struct regcache *regcache, int regnum,
	91	const void *gregs, size_t regsize)
	92	{
f7241d4f	93	struct gdbarch *gdbarch = get_regcache_arch (regcache);
387360da JB	94	const gdb_byte regs = (const gdb_byte ) gregs;
	95	int i;
	96
f7241d4f	97	for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
387360da JB	98	if (regnum == i \|\| regnum == -1)
	99	mips_fbsd_supply_reg (regcache, i, regs + i * regsize, regsize);
	100	}
	101
	102	/* Collect the floating-point registers from REGCACHE and store them
	103	in FPREGS. Each floating-point register in FPREGS is REGSIZE bytes
	104	in length. */
	105
	106	void
	107	mips_fbsd_collect_fpregs (const struct regcache *regcache, int regnum,
	108	void *fpregs, size_t regsize)
	109	{
f7241d4f	110	struct gdbarch *gdbarch = get_regcache_arch (regcache);
387360da	111	gdb_byte regs = (gdb_byte ) fpregs;
f7241d4f	112	int i, fp0num, fsrnum;
387360da	113
f7241d4f JB	114	fp0num = mips_regnum (gdbarch)->fp0;
	115	fsrnum = mips_regnum (gdbarch)->fp_control_status;
	116	for (i = fp0num; i <= fsrnum; i++)
387360da JB	117	if (regnum == i \|\| regnum == -1)
387360da JB	118	mips_fbsd_collect_reg (regcache, i,
f7241d4f	119	regs + (i - fp0num) * regsize, regsize);
387360da JB	120	}
	121
	122	/* Collect the general-purpose registers from REGCACHE and store them
	123	in GREGS. Each general-purpose register in GREGS is REGSIZE bytes
	124	in length. */
	125
	126	void
	127	mips_fbsd_collect_gregs (const struct regcache *regcache, int regnum,
	128	void *gregs, size_t regsize)
	129	{
f7241d4f	130	struct gdbarch *gdbarch = get_regcache_arch (regcache);
387360da JB	131	gdb_byte regs = (gdb_byte ) gregs;
	132	int i;
	133
f7241d4f	134	for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
387360da JB	135	if (regnum == i \|\| regnum == -1)
	136	mips_fbsd_collect_reg (regcache, i, regs + i * regsize, regsize);
	137	}
	138
	139	/* Supply register REGNUM from the buffer specified by FPREGS and LEN
	140	in the floating-point register set REGSET to register cache
	141	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	142
	143	static void
	144	mips_fbsd_supply_fpregset (const struct regset *regset,
	145	struct regcache *regcache,
	146	int regnum, const void *fpregs, size_t len)
	147	{
	148	size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
	149
	150	gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);
	151
	152	mips_fbsd_supply_fpregs (regcache, regnum, fpregs, regsize);
	153	}
	154
	155	/* Collect register REGNUM from the register cache REGCACHE and store
	156	it in the buffer specified by FPREGS and LEN in the floating-point
	157	register set REGSET. If REGNUM is -1, do this for all registers in
	158	REGSET. */
	159
	160	static void
	161	mips_fbsd_collect_fpregset (const struct regset *regset,
	162	const struct regcache *regcache,
	163	int regnum, void *fpregs, size_t len)
	164	{
	165	size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
	166
	167	gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);
	168
	169	mips_fbsd_collect_fpregs (regcache, regnum, fpregs, regsize);
	170	}
	171
	172	/* Supply register REGNUM from the buffer specified by GREGS and LEN
	173	in the general-purpose register set REGSET to register cache
	174	REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
	175
	176	static void
	177	mips_fbsd_supply_gregset (const struct regset *regset,
	178	struct regcache *regcache, int regnum,
	179	const void *gregs, size_t len)
	180	{
	181	size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
	182
	183	gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);
	184
	185	mips_fbsd_supply_gregs (regcache, regnum, gregs, regsize);
	186	}
	187
	188	/* Collect register REGNUM from the register cache REGCACHE and store
	189	it in the buffer specified by GREGS and LEN in the general-purpose
	190	register set REGSET. If REGNUM is -1, do this for all registers in
	191	REGSET. */
	192
	193	static void
	194	mips_fbsd_collect_gregset (const struct regset *regset,
	195	const struct regcache *regcache,
	196	int regnum, void *gregs, size_t len)
	197	{
	198	size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
199
200	gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);
201
202	mips_fbsd_collect_gregs (regcache, regnum, gregs, regsize);
203	}
204
205	/* FreeBSD/mips register sets. */
206
207	static const struct regset mips_fbsd_gregset =
208	{
209	NULL,
210	mips_fbsd_supply_gregset,
211	mips_fbsd_collect_gregset,
212	};
213
214	static const struct regset mips_fbsd_fpregset =
215	{
216	NULL,
217	mips_fbsd_supply_fpregset,
218	mips_fbsd_collect_fpregset,
219	};
220
221	/* Iterate over core file register note sections. */
222
223	static void
224	mips_fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
225	iterate_over_regset_sections_cb *cb,
226	void *cb_data,
227	const struct regcache *regcache)
228	{
229	size_t regsize = mips_abi_regsize (gdbarch);
230
231	cb (".reg", MIPS_FBSD_NUM_GREGS * regsize, &mips_fbsd_gregset,
232	NULL, cb_data);
233	cb (".reg2", MIPS_FBSD_NUM_FPREGS * regsize, &mips_fbsd_fpregset,
234	NULL, cb_data);
235	}
236
237	/* Signal trampoline support. */
238
239	#define FBSD_SYS_sigreturn 417
240
241	#define MIPS_INST_LI_V0_SIGRETURN 0x24020000 + FBSD_SYS_sigreturn
242	#define MIPS_INST_SYSCALL 0x0000000c
243	#define MIPS_INST_BREAK 0x0000000d
244
245	#define O32_SIGFRAME_UCONTEXT_OFFSET (16)
246	#define O32_SIGSET_T_SIZE (16)
247
248	#define O32_UCONTEXT_ONSTACK (O32_SIGSET_T_SIZE)
249	#define O32_UCONTEXT_PC (O32_UCONTEXT_ONSTACK + 4)
250	#define O32_UCONTEXT_REGS (O32_UCONTEXT_PC + 4)
251	#define O32_UCONTEXT_SR (O32_UCONTEXT_REGS + 4 * 32)
252	#define O32_UCONTEXT_LO (O32_UCONTEXT_SR + 4)
253	#define O32_UCONTEXT_HI (O32_UCONTEXT_LO + 4)
254	#define O32_UCONTEXT_FPUSED (O32_UCONTEXT_HI + 4)
255	#define O32_UCONTEXT_FPREGS (O32_UCONTEXT_FPUSED + 4)
256
257	#define O32_UCONTEXT_REG_SIZE 4
258
259	static void
260	mips_fbsd_sigframe_init (const struct tramp_frame *self,
261	struct frame_info *this_frame,
262	struct trad_frame_cache *cache,
263	CORE_ADDR func)
264	{
265	struct gdbarch *gdbarch = get_frame_arch (this_frame);
266	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
267	CORE_ADDR sp, ucontext_addr, addr;
268	int regnum;
269	gdb_byte buf[4];
270
271	/* We find the appropriate instance of `ucontext_t' at a
272	fixed offset in the signal frame. */
273	sp = get_frame_register_signed (this_frame,
274	MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
275	ucontext_addr = sp + O32_SIGFRAME_UCONTEXT_OFFSET;
276
277	/* PC. */
278	regnum = mips_regnum (gdbarch)->pc;
279	trad_frame_set_reg_addr (cache,
280	regnum + gdbarch_num_regs (gdbarch),
281	ucontext_addr + O32_UCONTEXT_PC);
282
283	/* GPRs. */
284	for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + O32_UCONTEXT_REGS;
285	regnum <= MIPS_RA_REGNUM; regnum++, addr += O32_UCONTEXT_REG_SIZE)
286	trad_frame_set_reg_addr (cache,
287	regnum + gdbarch_num_regs (gdbarch),
288	addr);
289
290	regnum = MIPS_PS_REGNUM;
291	trad_frame_set_reg_addr (cache,
292	regnum + gdbarch_num_regs (gdbarch),
293	ucontext_addr + O32_UCONTEXT_SR);
294
295	/* HI and LO. */
296	regnum = mips_regnum (gdbarch)->lo;
297	trad_frame_set_reg_addr (cache,
298	regnum + gdbarch_num_regs (gdbarch),
299	ucontext_addr + O32_UCONTEXT_LO);
300	regnum = mips_regnum (gdbarch)->hi;
301	trad_frame_set_reg_addr (cache,
302	regnum + gdbarch_num_regs (gdbarch),
303	ucontext_addr + O32_UCONTEXT_HI);
304
1c33cd7f YQ	305	if (target_read_memory (ucontext_addr + O32_UCONTEXT_FPUSED, buf, 4) == 0
1c33cd7f YQ	306	&& extract_unsigned_integer (buf, 4, byte_order) != 0)
387360da JB	307	{
	308	for (regnum = 0, addr = ucontext_addr + O32_UCONTEXT_FPREGS;
	309	regnum < 32; regnum++, addr += O32_UCONTEXT_REG_SIZE)
	310	trad_frame_set_reg_addr (cache,
	311	regnum + gdbarch_fp0_regnum (gdbarch),
	312	addr);
	313	trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
	314	addr);
	315	}
	316
	317	trad_frame_set_id (cache, frame_id_build (sp, func));
	318	}
	319
	320	#define MIPS_INST_ADDIU_A0_SP_O32 (0x27a40000 \
	321	+ O32_SIGFRAME_UCONTEXT_OFFSET)
	322
	323	static const struct tramp_frame mips_fbsd_sigframe =
	324	{
	325	SIGTRAMP_FRAME,
	326	MIPS_INSN32_SIZE,
	327	{
	328	{ MIPS_INST_ADDIU_A0_SP_O32, -1 }, /* addiu a0, sp, SIGF_UC */
	329	{ MIPS_INST_LI_V0_SIGRETURN, -1 }, /* li v0, SYS_sigreturn */
	330	{ MIPS_INST_SYSCALL, -1 }, /* syscall */
	331	{ MIPS_INST_BREAK, -1 }, /* break */
	332	{ TRAMP_SENTINEL_INSN, -1 }
	333	},
	334	mips_fbsd_sigframe_init
	335	};
	336
	337	#define N64_SIGFRAME_UCONTEXT_OFFSET (32)
	338	#define N64_SIGSET_T_SIZE (16)
	339
	340	#define N64_UCONTEXT_ONSTACK (N64_SIGSET_T_SIZE)
	341	#define N64_UCONTEXT_PC (N64_UCONTEXT_ONSTACK + 8)
	342	#define N64_UCONTEXT_REGS (N64_UCONTEXT_PC + 8)
	343	#define N64_UCONTEXT_SR (N64_UCONTEXT_REGS + 8 * 32)
	344	#define N64_UCONTEXT_LO (N64_UCONTEXT_SR + 8)
	345	#define N64_UCONTEXT_HI (N64_UCONTEXT_LO + 8)
	346	#define N64_UCONTEXT_FPUSED (N64_UCONTEXT_HI + 8)
	347	#define N64_UCONTEXT_FPREGS (N64_UCONTEXT_FPUSED + 8)
	348
	349	#define N64_UCONTEXT_REG_SIZE 8
	350
	351	static void
	352	mips64_fbsd_sigframe_init (const struct tramp_frame *self,
	353	struct frame_info *this_frame,
	354	struct trad_frame_cache *cache,
	355	CORE_ADDR func)
	356	{
	357	struct gdbarch *gdbarch = get_frame_arch (this_frame);
	358	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	359	CORE_ADDR sp, ucontext_addr, addr;
	360	int regnum;
	361	gdb_byte buf[4];
	362
	363	/* We find the appropriate instance of `ucontext_t' at a
	364	fixed offset in the signal frame. */
	365	sp = get_frame_register_signed (this_frame,
	366	MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
	367	ucontext_addr = sp + N64_SIGFRAME_UCONTEXT_OFFSET;
	368
	369	/* PC. */
	370	regnum = mips_regnum (gdbarch)->pc;
371	trad_frame_set_reg_addr (cache,
372	regnum + gdbarch_num_regs (gdbarch),
373	ucontext_addr + N64_UCONTEXT_PC);
374
375	/* GPRs. */
376	for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + N64_UCONTEXT_REGS;
377	regnum <= MIPS_RA_REGNUM; regnum++, addr += N64_UCONTEXT_REG_SIZE)
378	trad_frame_set_reg_addr (cache,
379	regnum + gdbarch_num_regs (gdbarch),
380	addr);
381
382	regnum = MIPS_PS_REGNUM;
383	trad_frame_set_reg_addr (cache,
384	regnum + gdbarch_num_regs (gdbarch),
385	ucontext_addr + N64_UCONTEXT_SR);
386
387	/* HI and LO. */
388	regnum = mips_regnum (gdbarch)->lo;
389	trad_frame_set_reg_addr (cache,
390	regnum + gdbarch_num_regs (gdbarch),
391	ucontext_addr + N64_UCONTEXT_LO);
392	regnum = mips_regnum (gdbarch)->hi;
393	trad_frame_set_reg_addr (cache,
394	regnum + gdbarch_num_regs (gdbarch),
395	ucontext_addr + N64_UCONTEXT_HI);
396
1c33cd7f YQ	397	if (target_read_memory (ucontext_addr + N64_UCONTEXT_FPUSED, buf, 4) == 0
1c33cd7f YQ	398	&& extract_unsigned_integer (buf, 4, byte_order) != 0)
387360da JB	399	{
	400	for (regnum = 0, addr = ucontext_addr + N64_UCONTEXT_FPREGS;
	401	regnum < 32; regnum++, addr += N64_UCONTEXT_REG_SIZE)
	402	trad_frame_set_reg_addr (cache,
	403	regnum + gdbarch_fp0_regnum (gdbarch),
	404	addr);
	405	trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
	406	addr);
	407	}
	408
	409	trad_frame_set_id (cache, frame_id_build (sp, func));
	410	}
	411
	412	#define MIPS_INST_DADDIU_A0_SP_N64 (0x67a40000 \
	413	+ N64_SIGFRAME_UCONTEXT_OFFSET)
	414
	415	static const struct tramp_frame mips64_fbsd_sigframe =
	416	{
	417	SIGTRAMP_FRAME,
	418	MIPS_INSN32_SIZE,
	419	{
	420	{ MIPS_INST_DADDIU_A0_SP_N64, -1 }, /* daddiu a0, sp, SIGF_UC */
	421	{ MIPS_INST_LI_V0_SIGRETURN, -1 }, /* li v0, SYS_sigreturn */
	422	{ MIPS_INST_SYSCALL, -1 }, /* syscall */
	423	{ MIPS_INST_BREAK, -1 }, /* break */
	424	{ TRAMP_SENTINEL_INSN, -1 }
	425	},
	426	mips64_fbsd_sigframe_init
	427	};
	428
	429	/* Shared library support. */
	430
	431	/* FreeBSD/mips uses a slightly different `struct link_map' than the
	432	other FreeBSD platforms as it includes an additional `l_off'
	433	member. */
	434
	435	static struct link_map_offsets *
	436	mips_fbsd_ilp32_fetch_link_map_offsets (void)
	437	{
	438	static struct link_map_offsets lmo;
	439	static struct link_map_offsets *lmp = NULL;
	440
	441	if (lmp == NULL)
	442	{
	443	lmp = &lmo;
	444
	445	lmo.r_version_offset = 0;
	446	lmo.r_version_size = 4;
	447	lmo.r_map_offset = 4;
	448	lmo.r_brk_offset = 8;
	449	lmo.r_ldsomap_offset = -1;
	450
	451	lmo.link_map_size = 24;
	452	lmo.l_addr_offset = 0;
	453	lmo.l_name_offset = 8;
	454	lmo.l_ld_offset = 12;
	455	lmo.l_next_offset = 16;
	456	lmo.l_prev_offset = 20;
	457	}
	458
	459	return lmp;
	460	}
	461
	462	static struct link_map_offsets *
463	mips_fbsd_lp64_fetch_link_map_offsets (void)
464	{
465	static struct link_map_offsets lmo;
466	static struct link_map_offsets *lmp = NULL;
467
468	if (lmp == NULL)
469	{
470	lmp = &lmo;
471
472	lmo.r_version_offset = 0;
473	lmo.r_version_size = 4;
474	lmo.r_map_offset = 8;
475	lmo.r_brk_offset = 16;
476	lmo.r_ldsomap_offset = -1;
477
478	lmo.link_map_size = 48;
479	lmo.l_addr_offset = 0;
480	lmo.l_name_offset = 16;
481	lmo.l_ld_offset = 24;
482	lmo.l_next_offset = 32;
483	lmo.l_prev_offset = 40;
484	}
485
486	return lmp;
487	}
488
489	static void
490	mips_fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
491	{
492	enum mips_abi abi = mips_abi (gdbarch);
493
494	/* Generic FreeBSD support. */
495	fbsd_init_abi (info, gdbarch);
496
497	set_gdbarch_software_single_step (gdbarch, mips_software_single_step);
498
499	switch (abi)
500	{
501	case MIPS_ABI_O32:
502	tramp_frame_prepend_unwinder (gdbarch, &mips_fbsd_sigframe);
503	break;
504	case MIPS_ABI_N32:
505	break;
506	case MIPS_ABI_N64:
507	tramp_frame_prepend_unwinder (gdbarch, &mips64_fbsd_sigframe);
508	break;
509	}
510
511	set_gdbarch_iterate_over_regset_sections
512	(gdbarch, mips_fbsd_iterate_over_regset_sections);
513
514	/* FreeBSD/mips has SVR4-style shared libraries. */
515	set_solib_svr4_fetch_link_map_offsets
516	(gdbarch, (gdbarch_ptr_bit (gdbarch) == 32 ?
517	mips_fbsd_ilp32_fetch_link_map_offsets :
518	mips_fbsd_lp64_fetch_link_map_offsets));
519	}
520	\f
521
522	/* Provide a prototype to silence -Wmissing-prototypes. */
523	void _initialize_mips_fbsd_tdep (void);
524
525	void
526	_initialize_mips_fbsd_tdep (void)
527	{
c988ac1d	528	gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_FREEBSD,
387360da JB	529	mips_fbsd_init_abi);
387360da JB	530	}