[binutils.git] / gdb / frv-linux-tdep.c

/* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
   for GDB.

   Copyright (C) 2004-2015 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 "gdbcore.h"
#include "target.h"
#include "frame.h"
#include "osabi.h"
#include "regcache.h"
#include "elf-bfd.h"
#include "elf/frv.h"
#include "frv-tdep.h"
#include "trad-frame.h"
#include "frame-unwind.h"
#include "regset.h"
#include "linux-tdep.h"

/* Define the size (in bytes) of an FR-V instruction.  */
static const int frv_instr_size = 4;

enum {
  NORMAL_SIGTRAMP = 1,
  RT_SIGTRAMP = 2
};

static int
frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
			  const char *name)
{
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  gdb_byte buf[frv_instr_size];
  LONGEST instr;
  int retval = 0;

  if (target_read_memory (pc, buf, sizeof buf) != 0)
    return 0;

  instr = extract_unsigned_integer (buf, sizeof buf, byte_order);

  if (instr == 0x8efc0077)	/* setlos #__NR_sigreturn, gr7 */
    retval = NORMAL_SIGTRAMP;
  else if (instr == 0x8efc00ad)	/* setlos #__NR_rt_sigreturn, gr7 */
    retval = RT_SIGTRAMP;
  else
    return 0;

  if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
    return 0;
  instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  if (instr != 0xc0700000)	/* tira	gr0, 0 */
    return 0;

  /* If we get this far, we'll return a non-zero value, either
     NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2).  */
  return retval;
}

/* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
   wish to decode, and REGNO, one of the frv register numbers defined
   in frv-tdep.h, return the address of the saved register (corresponding
   to REGNO) in the sigtramp frame.  Return -1 if the register is not
   found in the sigtramp frame.  The magic numbers in the code below
   were computed by examining the following kernel structs:

   From arch/frv/kernel/signal.c:

      struct sigframe
      {
	      void (*pretcode)(void);
	      int sig;
	      struct sigcontext sc;
	      unsigned long extramask[_NSIG_WORDS-1];
	      uint32_t retcode[2];
      };

      struct rt_sigframe
      {
	      void (*pretcode)(void);
	      int sig;
	      struct siginfo *pinfo;
	      void *puc;
	      struct siginfo info;
	      struct ucontext uc;
	      uint32_t retcode[2];
      };

   From include/asm-frv/ucontext.h:

      struct ucontext {
	      unsigned long		uc_flags;
	      struct ucontext		*uc_link;
	      stack_t			uc_stack;
	      struct sigcontext	uc_mcontext;
	      sigset_t		uc_sigmask;
      };

   From include/asm-frv/signal.h:

      typedef struct sigaltstack {
	      void *ss_sp;
	      int ss_flags;
	      size_t ss_size;
      } stack_t;

   From include/asm-frv/sigcontext.h:

      struct sigcontext {
	      struct user_context	sc_context;
	      unsigned long		sc_oldmask;
      } __attribute__((aligned(8)));

   From include/asm-frv/registers.h:
      struct user_int_regs
      {
	      unsigned long		psr;
	      unsigned long		isr;
	      unsigned long		ccr;
	      unsigned long		cccr;
	      unsigned long		lr;
	      unsigned long		lcr;
	      unsigned long		pc;
	      unsigned long		__status;
	      unsigned long		syscallno;
	      unsigned long		orig_gr8;
	      unsigned long		gner[2];
	      unsigned long long	iacc[1];

	      union {
		      unsigned long	tbr;
		      unsigned long	gr[64];
	      };
      };

      struct user_fpmedia_regs
      {
	      unsigned long	fr[64];
	      unsigned long	fner[2];
	      unsigned long	msr[2];
	      unsigned long	acc[8];
	      unsigned char	accg[8];
	      unsigned long	fsr[1];
      };

      struct user_context
      {
	      struct user_int_regs		i;
	      struct user_fpmedia_regs	f;

	      void *extension;
      } __attribute__((aligned(8)));  */

static LONGEST
frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
                               CORE_ADDR *sc_addr_cache_ptr)
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  CORE_ADDR sc_addr;

  if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
    {
      sc_addr = *sc_addr_cache_ptr;
    }
  else
    {
      CORE_ADDR pc, sp;
      gdb_byte buf[4];
      int tramp_type;

      pc = get_frame_pc (this_frame);
      tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);

      get_frame_register (this_frame, sp_regnum, buf);
      sp = extract_unsigned_integer (buf, sizeof buf, byte_order);

      if (tramp_type == NORMAL_SIGTRAMP)
	{
	  /* For a normal sigtramp frame, the sigcontext struct starts
	     at SP + 8.  */
	  sc_addr = sp + 8;
	}
      else if (tramp_type == RT_SIGTRAMP)
	{
	  /* For a realtime sigtramp frame, SP + 12 contains a pointer
 	     to a ucontext struct.  The ucontext struct contains a
 	     sigcontext struct starting 24 bytes in.  (The offset of
 	     uc_mcontext within struct ucontext is derived as follows: 
 	     stack_t is a 12-byte struct and struct sigcontext is
 	     8-byte aligned.  This gives an offset of 8 + 12 + 4 (for
 	     padding) = 24.)  */
	  if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
	    {
	      warning (_("Can't read realtime sigtramp frame."));
	      return 0;
	    }
	  sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
 	  sc_addr += 24;
	}
      else
	internal_error (__FILE__, __LINE__, _("not a signal trampoline"));

      if (sc_addr_cache_ptr)
	*sc_addr_cache_ptr = sc_addr;
    }

  switch (regno)
    {
    case psr_regnum :
      return sc_addr + 0;
    /* sc_addr + 4 has "isr", the Integer Status Register.  */
    case ccr_regnum :
      return sc_addr + 8;
    case cccr_regnum :
      return sc_addr + 12;
    case lr_regnum :
      return sc_addr + 16;
    case lcr_regnum :
      return sc_addr + 20;
    case pc_regnum :
      return sc_addr + 24;
    /* sc_addr + 28 is __status, the exception status.
       sc_addr + 32 is syscallno, the syscall number or -1.
       sc_addr + 36 is orig_gr8, the original syscall arg #1.
       sc_addr + 40 is gner[0].
       sc_addr + 44 is gner[1].  */
    case iacc0h_regnum :
      return sc_addr + 48;
    case iacc0l_regnum :
      return sc_addr + 52;
    default : 
      if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
	return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
      else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
	return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
      else
	return -1;  /* not saved.  */
    }
}

/* Signal trampolines.  */

static struct trad_frame_cache *
frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
				void **this_cache)
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  struct trad_frame_cache *cache;
  CORE_ADDR addr;
  gdb_byte buf[4];
  int regnum;
  CORE_ADDR sc_addr_cache_val = 0;
  struct frame_id this_id;

  if (*this_cache)
    return *this_cache;

  cache = trad_frame_cache_zalloc (this_frame);

  /* FIXME: cagney/2004-05-01: This is is long standing broken code.
     The frame ID's code address should be the start-address of the
     signal trampoline and not the current PC within that
     trampoline.  */
  get_frame_register (this_frame, sp_regnum, buf);
  addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  this_id = frame_id_build (addr, get_frame_pc (this_frame));
  trad_frame_set_id (cache, this_id);

  for (regnum = 0; regnum < frv_num_regs; regnum++)
    {
      LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
							&sc_addr_cache_val);
      if (reg_addr != -1)
	trad_frame_set_reg_addr (cache, regnum, reg_addr);
    }

  *this_cache = cache;
  return cache;
}

static void
frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
				  void **this_cache,
				  struct frame_id *this_id)
{
  struct trad_frame_cache *cache
    = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
  trad_frame_get_id (cache, this_id);
}

static struct value *
frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
					void **this_cache, int regnum)
{
  /* Make sure we've initialized the cache.  */
  struct trad_frame_cache *cache
    = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
  return trad_frame_get_register (cache, this_frame, regnum);
}

static int
frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
				  struct frame_info *this_frame,
				  void **this_cache)
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  CORE_ADDR pc = get_frame_pc (this_frame);
  const char *name;

  find_pc_partial_function (pc, &name, NULL, NULL);
  if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
    return 1;

  return 0;
}

static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
{
  SIGTRAMP_FRAME,
  default_frame_unwind_stop_reason,
  frv_linux_sigtramp_frame_this_id,
  frv_linux_sigtramp_frame_prev_register,
  NULL,
  frv_linux_sigtramp_frame_sniffer
};
\f
/* The FRV kernel defines ELF_NGREG as 46.  We add 2 in order to include
   the loadmap addresses in the register set.  (See below for more info.)  */
#define FRV_ELF_NGREG (46 + 2)
typedef unsigned char frv_elf_greg_t[4];
typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;

typedef unsigned char frv_elf_fpreg_t[4];
typedef struct
{
  frv_elf_fpreg_t fr[64];
  frv_elf_fpreg_t fner[2];
  frv_elf_fpreg_t msr[2];
  frv_elf_fpreg_t acc[8];
  unsigned char accg[8];
  frv_elf_fpreg_t fsr[1];
} frv_elf_fpregset_t;

/* Register maps.  */

static const struct regcache_map_entry frv_linux_gregmap[] =
  {
    { 1, psr_regnum, 4 },
    { 1, REGCACHE_MAP_SKIP, 4 }, /* isr */
    { 1, ccr_regnum, 4 },
    { 1, cccr_regnum, 4 },
    { 1, lr_regnum, 4 },
    { 1, lcr_regnum, 4 },
    { 1, pc_regnum, 4 },
    { 1, REGCACHE_MAP_SKIP, 4 }, /* __status */
    { 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */
    { 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */
    { 1, gner0_regnum, 4 },
    { 1, gner1_regnum, 4 },
    { 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */
    { 1, tbr_regnum, 4 },
    { 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */

    /* Technically, the loadmap addresses are not part of `pr_reg' as
       found in the elf_prstatus struct.  The fields which communicate
       the loadmap address appear (by design) immediately after
       `pr_reg' though, and the BFD function elf32_frv_grok_prstatus()
       has been implemented to include these fields in the register
       section that it extracts from the core file.  So, for our
       purposes, they may be viewed as registers.  */

    { 1, fdpic_loadmap_exec_regnum, 4 },
    { 1, fdpic_loadmap_interp_regnum, 4 },
    { 0 }
  };

static const struct regcache_map_entry frv_linux_fpregmap[] =
  {
    { 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */
    { 1, fner0_regnum, 4 },
    { 1, fner1_regnum, 4 },
    { 1, msr0_regnum, 4 },
    { 1, msr1_regnum, 4 },
    { 8, acc0_regnum, 4 },	/* acc0 ... acc7 */
    { 1, accg0123_regnum, 4 },
    { 1, accg4567_regnum, 4 },
    { 1, fsr0_regnum, 4 },
    { 0 }
  };

/* Unpack an frv_elf_gregset_t into GDB's register cache.  */

static void 
frv_linux_supply_gregset (const struct regset *regset,
                          struct regcache *regcache,
			  int regnum, const void *gregs, size_t len)
{
  int regi;
  char zerobuf[MAX_REGISTER_SIZE];

  memset (zerobuf, 0, MAX_REGISTER_SIZE);

  /* gr0 always contains 0.  Also, the kernel passes the TBR value in
     this slot.  */
  regcache_raw_supply (regcache, first_gpr_regnum, zerobuf);

  /* Fill gr32, ..., gr63 with zeros. */
  for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++)
    regcache_raw_supply (regcache, regi, zerobuf);

  regcache_supply_regset (regset, regcache, regnum, gregs, len);
}

/* FRV Linux kernel register sets.  */

static const struct regset frv_linux_gregset =
{
  frv_linux_gregmap,
  frv_linux_supply_gregset, regcache_collect_regset
};

static const struct regset frv_linux_fpregset =
{
  frv_linux_fpregmap,
  regcache_supply_regset, regcache_collect_regset
};

static void
frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
					iterate_over_regset_sections_cb *cb,
					void *cb_data,
					const struct regcache *regcache)
{
  cb (".reg", sizeof (frv_elf_gregset_t), &frv_linux_gregset,
      NULL, cb_data);
  cb (".reg2", sizeof (frv_elf_fpregset_t), &frv_linux_fpregset,
      NULL, cb_data);
}

\f
static void
frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  linux_init_abi (info, gdbarch);

  /* Set the sigtramp frame sniffer.  */
  frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind); 

  set_gdbarch_iterate_over_regset_sections
    (gdbarch, frv_linux_iterate_over_regset_sections);
}

static enum gdb_osabi
frv_linux_elf_osabi_sniffer (bfd *abfd)
{
  int elf_flags;

  elf_flags = elf_elfheader (abfd)->e_flags;

  /* Assume GNU/Linux if using the FDPIC ABI.  If/when another OS shows
     up that uses this ABI, we'll need to start using .note sections
     or some such.  */
  if (elf_flags & EF_FRV_FDPIC)
    return GDB_OSABI_LINUX;
  else
    return GDB_OSABI_UNKNOWN;
}

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

void
_initialize_frv_linux_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
			  frv_linux_init_abi);
  gdbarch_register_osabi_sniffer (bfd_arch_frv,
				  bfd_target_elf_flavour,
				  frv_linux_elf_osabi_sniffer);
}
Commit	Line	Data
5ecb7103 KB	1	/* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
5ecb7103 KB	2	for GDB.
155bd5d1	3
32d0add0	4	Copyright (C) 2004-2015 Free Software Foundation, Inc.
5ecb7103 KB	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
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
5ecb7103 KB	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
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
5ecb7103 KB	20
5ecb7103 KB	21	#include "defs.h"
7c699b81	22	#include "gdbcore.h"
5ecb7103 KB	23	#include "target.h"
	24	#include "frame.h"
	25	#include "osabi.h"
7c699b81	26	#include "regcache.h"
5ecb7103 KB	27	#include "elf-bfd.h"
	28	#include "elf/frv.h"
	29	#include "frv-tdep.h"
9df0bb3f AC	30	#include "trad-frame.h"
9df0bb3f AC	31	#include "frame-unwind.h"
7c699b81	32	#include "regset.h"
a5ee0f0c	33	#include "linux-tdep.h"
5ecb7103 KB	34
	35	/* Define the size (in bytes) of an FR-V instruction. */
	36	static const int frv_instr_size = 4;
	37
	38	enum {
	39	NORMAL_SIGTRAMP = 1,
	40	RT_SIGTRAMP = 2
	41	};
	42
	43	static int
2c02bd72 DE	44	frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
2c02bd72 DE	45	const char *name)
5ecb7103	46	{
e17a4113	47	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
e362b510	48	gdb_byte buf[frv_instr_size];
5ecb7103 KB	49	LONGEST instr;
	50	int retval = 0;
	51
	52	if (target_read_memory (pc, buf, sizeof buf) != 0)
	53	return 0;
	54
e17a4113	55	instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
5ecb7103 KB	56
	57	if (instr == 0x8efc0077) /* setlos #__NR_sigreturn, gr7 */
	58	retval = NORMAL_SIGTRAMP;
137a83b9	59	else if (instr == 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */
5ecb7103 KB	60	retval = RT_SIGTRAMP;
	61	else
	62	return 0;
	63
	64	if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
	65	return 0;
e17a4113	66	instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
5ecb7103 KB	67	if (instr != 0xc0700000) /* tira gr0, 0 */
	68	return 0;
	69
	70	/* If we get this far, we'll return a non-zero value, either
	71	NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2). */
	72	return retval;
	73	}
	74
f79d2c3c	75	/* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
5ecb7103 KB	76	wish to decode, and REGNO, one of the frv register numbers defined
	77	in frv-tdep.h, return the address of the saved register (corresponding
	78	to REGNO) in the sigtramp frame. Return -1 if the register is not
	79	found in the sigtramp frame. The magic numbers in the code below
	80	were computed by examining the following kernel structs:
	81
f79d2c3c	82	From arch/frv/kernel/signal.c:
5ecb7103 KB	83
	84	struct sigframe
	85	{
	86	void (*pretcode)(void);
	87	int sig;
	88	struct sigcontext sc;
	89	unsigned long extramask[_NSIG_WORDS-1];
	90	uint32_t retcode[2];
	91	};
	92
	93	struct rt_sigframe
	94	{
	95	void (*pretcode)(void);
	96	int sig;
	97	struct siginfo *pinfo;
	98	void *puc;
	99	struct siginfo info;
	100	struct ucontext uc;
	101	uint32_t retcode[2];
	102	};
	103
f79d2c3c	104	From include/asm-frv/ucontext.h:
5ecb7103 KB	105
	106	struct ucontext {
	107	unsigned long uc_flags;
	108	struct ucontext *uc_link;
	109	stack_t uc_stack;
	110	struct sigcontext uc_mcontext;
	111	sigset_t uc_sigmask;
	112	};
	113
f79d2c3c KB	114	From include/asm-frv/signal.h:
	115
	116	typedef struct sigaltstack {
	117	void *ss_sp;
	118	int ss_flags;
	119	size_t ss_size;
	120	} stack_t;
	121
	122	From include/asm-frv/sigcontext.h:
5ecb7103 KB	123
	124	struct sigcontext {
	125	struct user_context sc_context;
	126	unsigned long sc_oldmask;
	127	} __attribute__((aligned(8)));
	128
f79d2c3c	129	From include/asm-frv/registers.h:
5ecb7103 KB	130	struct user_int_regs
	131	{
	132	unsigned long psr;
	133	unsigned long isr;
	134	unsigned long ccr;
	135	unsigned long cccr;
	136	unsigned long lr;
	137	unsigned long lcr;
	138	unsigned long pc;
	139	unsigned long __status;
	140	unsigned long syscallno;
	141	unsigned long orig_gr8;
	142	unsigned long gner[2];
	143	unsigned long long iacc[1];
	144
	145	union {
	146	unsigned long tbr;
	147	unsigned long gr[64];
	148	};
	149	};
	150
	151	struct user_fpmedia_regs
	152	{
	153	unsigned long fr[64];
	154	unsigned long fner[2];
	155	unsigned long msr[2];
	156	unsigned long acc[8];
	157	unsigned char accg[8];
	158	unsigned long fsr[1];
	159	};
	160
	161	struct user_context
	162	{
	163	struct user_int_regs i;
	164	struct user_fpmedia_regs f;
	165
	166	void *extension;
	167	} __attribute__((aligned(8))); */
	168
9df0bb3f	169	static LONGEST
94afd7a6	170	frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
5ecb7103 KB	171	CORE_ADDR *sc_addr_cache_ptr)
5ecb7103 KB	172	{
e17a4113 UW	173	struct gdbarch *gdbarch = get_frame_arch (this_frame);
e17a4113 UW	174	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5ecb7103 KB	175	CORE_ADDR sc_addr;
	176
	177	if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
	178	{
	179	sc_addr = *sc_addr_cache_ptr;
	180	}
	181	else
	182	{
	183	CORE_ADDR pc, sp;
e362b510	184	gdb_byte buf[4];
5ecb7103 KB	185	int tramp_type;
5ecb7103 KB	186
94afd7a6	187	pc = get_frame_pc (this_frame);
e17a4113	188	tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);
5ecb7103	189
94afd7a6	190	get_frame_register (this_frame, sp_regnum, buf);
e17a4113	191	sp = extract_unsigned_integer (buf, sizeof buf, byte_order);
5ecb7103 KB	192
	193	if (tramp_type == NORMAL_SIGTRAMP)
	194	{
	195	/* For a normal sigtramp frame, the sigcontext struct starts
	196	at SP + 8. */
	197	sc_addr = sp + 8;
	198	}
	199	else if (tramp_type == RT_SIGTRAMP)
	200	{
	201	/* For a realtime sigtramp frame, SP + 12 contains a pointer
4f0d78e0	202	to a ucontext struct. The ucontext struct contains a
f79d2c3c KB	203	sigcontext struct starting 24 bytes in. (The offset of
	204	uc_mcontext within struct ucontext is derived as follows:
	205	stack_t is a 12-byte struct and struct sigcontext is
	206	8-byte aligned. This gives an offset of 8 + 12 + 4 (for
0963b4bd	207	padding) = 24.) */
5ecb7103 KB	208	if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
5ecb7103 KB	209	{
8a3fe4f8	210	warning (_("Can't read realtime sigtramp frame."));
5ecb7103 KB	211	return 0;
5ecb7103 KB	212	}
e17a4113	213	sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
f79d2c3c	214	sc_addr += 24;
5ecb7103 KB	215	}
5ecb7103 KB	216	else
e2e0b3e5	217	internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
5ecb7103 KB	218
	219	if (sc_addr_cache_ptr)
	220	*sc_addr_cache_ptr = sc_addr;
	221	}
	222
	223	switch (regno)
	224	{
	225	case psr_regnum :
	226	return sc_addr + 0;
	227	/* sc_addr + 4 has "isr", the Integer Status Register. */
	228	case ccr_regnum :
	229	return sc_addr + 8;
	230	case cccr_regnum :
	231	return sc_addr + 12;
	232	case lr_regnum :
	233	return sc_addr + 16;
	234	case lcr_regnum :
	235	return sc_addr + 20;
	236	case pc_regnum :
	237	return sc_addr + 24;
	238	/* sc_addr + 28 is __status, the exception status.
	239	sc_addr + 32 is syscallno, the syscall number or -1.
	240	sc_addr + 36 is orig_gr8, the original syscall arg #1.
	241	sc_addr + 40 is gner[0].
0963b4bd	242	sc_addr + 44 is gner[1]. */
5ecb7103 KB	243	case iacc0h_regnum :
	244	return sc_addr + 48;
	245	case iacc0l_regnum :
	246	return sc_addr + 52;
	247	default :
	248	if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
	249	return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
	250	else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
	251	return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
	252	else
0963b4bd	253	return -1; /* not saved. */
5ecb7103 KB	254	}
	255	}
	256
9df0bb3f AC	257	/* Signal trampolines. */
	258
	259	static struct trad_frame_cache *
0963b4bd MS	260	frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
0963b4bd MS	261	void **this_cache)
9df0bb3f	262	{
e17a4113 UW	263	struct gdbarch *gdbarch = get_frame_arch (this_frame);
	264	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	265	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
9df0bb3f	266	struct trad_frame_cache *cache;
9df0bb3f	267	CORE_ADDR addr;
e362b510	268	gdb_byte buf[4];
9df0bb3f AC	269	int regnum;
	270	CORE_ADDR sc_addr_cache_val = 0;
	271	struct frame_id this_id;
	272
	273	if (*this_cache)
	274	return *this_cache;
	275
94afd7a6	276	cache = trad_frame_cache_zalloc (this_frame);
9df0bb3f AC	277
	278	/* FIXME: cagney/2004-05-01: This is is long standing broken code.
	279	The frame ID's code address should be the start-address of the
	280	signal trampoline and not the current PC within that
	281	trampoline. */
94afd7a6	282	get_frame_register (this_frame, sp_regnum, buf);
e17a4113 UW	283	addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
e17a4113 UW	284	this_id = frame_id_build (addr, get_frame_pc (this_frame));
9df0bb3f AC	285	trad_frame_set_id (cache, this_id);
	286
	287	for (regnum = 0; regnum < frv_num_regs; regnum++)
	288	{
94afd7a6	289	LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
9df0bb3f AC	290	&sc_addr_cache_val);
	291	if (reg_addr != -1)
	292	trad_frame_set_reg_addr (cache, regnum, reg_addr);
	293	}
	294
	295	*this_cache = cache;
	296	return cache;
	297	}
	298
	299	static void
0963b4bd MS	300	frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
	301	void **this_cache,
	302	struct frame_id *this_id)
9df0bb3f	303	{
0963b4bd MS	304	struct trad_frame_cache *cache
0963b4bd MS	305	= frv_linux_sigtramp_frame_cache (this_frame, this_cache);
9df0bb3f AC	306	trad_frame_get_id (cache, this_id);
	307	}
	308
94afd7a6 UW	309	static struct value *
	310	frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
	311	void **this_cache, int regnum)
9df0bb3f AC	312	{
9df0bb3f AC	313	/* Make sure we've initialized the cache. */
0963b4bd MS	314	struct trad_frame_cache *cache
0963b4bd MS	315	= frv_linux_sigtramp_frame_cache (this_frame, this_cache);
94afd7a6	316	return trad_frame_get_register (cache, this_frame, regnum);
9df0bb3f AC	317	}
9df0bb3f AC	318
94afd7a6 UW	319	static int
	320	frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
	321	struct frame_info *this_frame,
	322	void **this_cache)
9df0bb3f	323	{
e17a4113	324	struct gdbarch *gdbarch = get_frame_arch (this_frame);
94afd7a6	325	CORE_ADDR pc = get_frame_pc (this_frame);
2c02bd72	326	const char *name;
9df0bb3f AC	327
9df0bb3f AC	328	find_pc_partial_function (pc, &name, NULL, NULL);
e17a4113	329	if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
94afd7a6	330	return 1;
9df0bb3f	331
94afd7a6	332	return 0;
9df0bb3f AC	333	}
9df0bb3f AC	334
94afd7a6 UW	335	static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
	336	{
	337	SIGTRAMP_FRAME,
8fbca658	338	default_frame_unwind_stop_reason,
94afd7a6 UW	339	frv_linux_sigtramp_frame_this_id,
	340	frv_linux_sigtramp_frame_prev_register,
	341	NULL,
	342	frv_linux_sigtramp_frame_sniffer
	343	};
7c699b81 KB	344	\f
	345	/* The FRV kernel defines ELF_NGREG as 46. We add 2 in order to include
	346	the loadmap addresses in the register set. (See below for more info.) */
	347	#define FRV_ELF_NGREG (46 + 2)
	348	typedef unsigned char frv_elf_greg_t[4];
	349	typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;
	350
	351	typedef unsigned char frv_elf_fpreg_t[4];
	352	typedef struct
	353	{
	354	frv_elf_fpreg_t fr[64];
	355	frv_elf_fpreg_t fner[2];
	356	frv_elf_fpreg_t msr[2];
	357	frv_elf_fpreg_t acc[8];
	358	unsigned char accg[8];
	359	frv_elf_fpreg_t fsr[1];
	360	} frv_elf_fpregset_t;
	361
901e1b23 AA	362	/* Register maps. */
	363
	364	static const struct regcache_map_entry frv_linux_gregmap[] =
	365	{
	366	{ 1, psr_regnum, 4 },
	367	{ 1, REGCACHE_MAP_SKIP, 4 }, /* isr */
	368	{ 1, ccr_regnum, 4 },
	369	{ 1, cccr_regnum, 4 },
	370	{ 1, lr_regnum, 4 },
	371	{ 1, lcr_regnum, 4 },
	372	{ 1, pc_regnum, 4 },
	373	{ 1, REGCACHE_MAP_SKIP, 4 }, /* __status */
	374	{ 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */
	375	{ 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */
	376	{ 1, gner0_regnum, 4 },
	377	{ 1, gner1_regnum, 4 },
	378	{ 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */
	379	{ 1, tbr_regnum, 4 },
	380	{ 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */
	381
	382	/* Technically, the loadmap addresses are not part of `pr_reg' as
	383	found in the elf_prstatus struct. The fields which communicate
	384	the loadmap address appear (by design) immediately after
	385	`pr_reg' though, and the BFD function elf32_frv_grok_prstatus()
	386	has been implemented to include these fields in the register
	387	section that it extracts from the core file. So, for our
	388	purposes, they may be viewed as registers. */
	389
	390	{ 1, fdpic_loadmap_exec_regnum, 4 },
	391	{ 1, fdpic_loadmap_interp_regnum, 4 },
	392	{ 0 }
	393	};
	394
	395	static const struct regcache_map_entry frv_linux_fpregmap[] =
	396	{
	397	{ 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */
	398	{ 1, fner0_regnum, 4 },
	399	{ 1, fner1_regnum, 4 },
	400	{ 1, msr0_regnum, 4 },
	401	{ 1, msr1_regnum, 4 },
	402	{ 8, acc0_regnum, 4 }, /* acc0 ... acc7 */
	403	{ 1, accg0123_regnum, 4 },
	404	{ 1, accg4567_regnum, 4 },
	405	{ 1, fsr0_regnum, 4 },
	406	{ 0 }
	407	};
7c699b81 KB	408
	409	/* Unpack an frv_elf_gregset_t into GDB's register cache. */
	410
	411	static void
	412	frv_linux_supply_gregset (const struct regset *regset,
	413	struct regcache *regcache,
	414	int regnum, const void *gregs, size_t len)
	415	{
	416	int regi;
	417	char zerobuf[MAX_REGISTER_SIZE];
7c699b81 KB	418
	419	memset (zerobuf, 0, MAX_REGISTER_SIZE);
	420
	421	/* gr0 always contains 0. Also, the kernel passes the TBR value in
	422	this slot. */
	423	regcache_raw_supply (regcache, first_gpr_regnum, zerobuf);
	424
901e1b23 AA	425	/* Fill gr32, ..., gr63 with zeros. */
	426	for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++)
	427	regcache_raw_supply (regcache, regi, zerobuf);
7c699b81	428
901e1b23	429	regcache_supply_regset (regset, regcache, regnum, gregs, len);
7c699b81 KB	430	}
7c699b81 KB	431
155bd5d1	432	/* FRV Linux kernel register sets. */
7c699b81	433
3ca7dae4	434	static const struct regset frv_linux_gregset =
7c699b81	435	{
901e1b23 AA	436	frv_linux_gregmap,
901e1b23 AA	437	frv_linux_supply_gregset, regcache_collect_regset
7c699b81 KB	438	};
7c699b81 KB	439
3ca7dae4	440	static const struct regset frv_linux_fpregset =
7c699b81	441	{
901e1b23 AA	442	frv_linux_fpregmap,
901e1b23 AA	443	regcache_supply_regset, regcache_collect_regset
7c699b81 KB	444	};
7c699b81 KB	445
66afae4f AA	446	static void
	447	frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
	448	iterate_over_regset_sections_cb *cb,
	449	void *cb_data,
	450	const struct regcache *regcache)
7c699b81	451	{
66afae4f AA	452	cb (".reg", sizeof (frv_elf_gregset_t), &frv_linux_gregset,
	453	NULL, cb_data);
	454	cb (".reg2", sizeof (frv_elf_fpregset_t), &frv_linux_fpregset,
	455	NULL, cb_data);
7c699b81 KB	456	}
	457
	458	\f
5ecb7103 KB	459	static void
	460	frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	461	{
a5ee0f0c PA	462	linux_init_abi (info, gdbarch);
a5ee0f0c PA	463
9df0bb3f	464	/* Set the sigtramp frame sniffer. */
94afd7a6	465	frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind);
a5ee0f0c	466
66afae4f AA	467	set_gdbarch_iterate_over_regset_sections
66afae4f AA	468	(gdbarch, frv_linux_iterate_over_regset_sections);
5ecb7103 KB	469	}
	470
	471	static enum gdb_osabi
	472	frv_linux_elf_osabi_sniffer (bfd *abfd)
	473	{
	474	int elf_flags;
	475
	476	elf_flags = elf_elfheader (abfd)->e_flags;
	477
	478	/* Assume GNU/Linux if using the FDPIC ABI. If/when another OS shows
	479	up that uses this ABI, we'll need to start using .note sections
	480	or some such. */
	481	if (elf_flags & EF_FRV_FDPIC)
	482	return GDB_OSABI_LINUX;
	483	else
	484	return GDB_OSABI_UNKNOWN;
	485	}
	486
	487	/* Provide a prototype to silence -Wmissing-prototypes. */
	488	void _initialize_frv_linux_tdep (void);
	489
	490	void
	491	_initialize_frv_linux_tdep (void)
	492	{
0963b4bd MS	493	gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
0963b4bd MS	494	frv_linux_init_abi);
5ecb7103 KB	495	gdbarch_register_osabi_sniffer (bfd_arch_frv,
	496	bfd_target_elf_flavour,
	497	frv_linux_elf_osabi_sniffer);
	498	}