[deliverable/binutils-gdb.git] / gdb / m32r-linux-tdep.c

/* Target-dependent code for GNU/Linux m32r.

   Copyright (C) 2004, 2007, 2008 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 "frame.h"
#include "value.h"
#include "regcache.h"
#include "inferior.h"
#include "osabi.h"
#include "reggroups.h"
#include "regset.h"

#include "gdb_string.h"

#include "glibc-tdep.h"
#include "solib-svr4.h"
#include "symtab.h"

#include "trad-frame.h"
#include "frame-unwind.h"

#include "m32r-tdep.h"
\f

/* Recognizing signal handler frames.  */

/* GNU/Linux has two flavors of signals.  Normal signal handlers, and
   "realtime" (RT) signals.  The RT signals can provide additional
   information to the signal handler if the SA_SIGINFO flag is set
   when establishing a signal handler using `sigaction'.  It is not
   unlikely that future versions of GNU/Linux will support SA_SIGINFO
   for normal signals too.  */

/* When the m32r Linux kernel calls a signal handler and the
   SA_RESTORER flag isn't set, the return address points to a bit of
   code on the stack.  This function returns whether the PC appears to
   be within this bit of code.

   The instruction sequence for normal signals is
       ldi    r7, #__NR_sigreturn
       trap   #2
   or 0x67 0x77 0x10 0xf2.

   Checking for the code sequence should be somewhat reliable, because
   the effect is to call the system call sigreturn.  This is unlikely
   to occur anywhere other than in a signal trampoline.

   It kind of sucks that we have to read memory from the process in
   order to identify a signal trampoline, but there doesn't seem to be
   any other way.  Therefore we only do the memory reads if no
   function name could be identified, which should be the case since
   the code is on the stack.

   Detection of signal trampolines for handlers that set the
   SA_RESTORER flag is in general not possible.  Unfortunately this is
   what the GNU C Library has been doing for quite some time now.
   However, as of version 2.1.2, the GNU C Library uses signal
   trampolines (named __restore and __restore_rt) that are identical
   to the ones used by the kernel.  Therefore, these trampolines are
   supported too.  */

static const gdb_byte linux_sigtramp_code[] = {
  0x67, 0x77, 0x10, 0xf2,
};

/* If PC is in a sigtramp routine, return the address of the start of
   the routine.  Otherwise, return 0.  */

static CORE_ADDR
m32r_linux_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
{
  gdb_byte buf[4];

  /* We only recognize a signal trampoline if PC is at the start of
     one of the instructions.  We optimize for finding the PC at the
     start of the instruction sequence, as will be the case when the
     trampoline is not the first frame on the stack.  We assume that
     in the case where the PC is not at the start of the instruction
     sequence, there will be a few trailing readable bytes on the
     stack.  */

  if (pc % 2 != 0)
    {
      if (!safe_frame_unwind_memory (next_frame, pc, buf, 2))
	return 0;

      if (memcmp (buf, linux_sigtramp_code, 2) == 0)
	pc -= 2;
      else
	return 0;
    }

  if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
    return 0;

  if (memcmp (buf, linux_sigtramp_code, 4) != 0)
    return 0;

  return pc;
}

/* This function does the same for RT signals.  Here the instruction
   sequence is
       ldi    r7, #__NR_rt_sigreturn
       trap   #2
   or 0x97 0xf0 0x00 0xad 0x10 0xf2 0xf0 0x00.

   The effect is to call the system call rt_sigreturn.  */

static const gdb_byte linux_rt_sigtramp_code[] = {
  0x97, 0xf0, 0x00, 0xad, 0x10, 0xf2, 0xf0, 0x00,
};

/* If PC is in a RT sigtramp routine, return the address of the start
   of the routine.  Otherwise, return 0.  */

static CORE_ADDR
m32r_linux_rt_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
{
  gdb_byte buf[4];

  /* We only recognize a signal trampoline if PC is at the start of
     one of the instructions.  We optimize for finding the PC at the
     start of the instruction sequence, as will be the case when the
     trampoline is not the first frame on the stack.  We assume that
     in the case where the PC is not at the start of the instruction
     sequence, there will be a few trailing readable bytes on the
     stack.  */

  if (pc % 2 != 0)
    return 0;

  if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
    return 0;

  if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
    {
      if (!safe_frame_unwind_memory (next_frame, pc + 4, buf, 4))
	return 0;

      if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
	return pc;
    }
  else if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
    {
      if (!safe_frame_unwind_memory (next_frame, pc - 4, buf, 4))
	return 0;

      if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
	return pc - 4;
    }

  return 0;
}

static int
m32r_linux_pc_in_sigtramp (CORE_ADDR pc, char *name,
			   struct frame_info *next_frame)
{
  /* If we have NAME, we can optimize the search.  The trampolines are
     named __restore and __restore_rt.  However, they aren't dynamically
     exported from the shared C library, so the trampoline may appear to
     be part of the preceding function.  This should always be sigaction,
     __sigaction, or __libc_sigaction (all aliases to the same function).  */
  if (name == NULL || strstr (name, "sigaction") != NULL)
    return (m32r_linux_sigtramp_start (pc, next_frame) != 0
	    || m32r_linux_rt_sigtramp_start (pc, next_frame) != 0);

  return (strcmp ("__restore", name) == 0
	  || strcmp ("__restore_rt", name) == 0);
}

/* From <asm/sigcontext.h>.  */
static int m32r_linux_sc_reg_offset[] = {
  4 * 4,			/* r0 */
  5 * 4,			/* r1 */
  6 * 4,			/* r2 */
  7 * 4,			/* r3 */
  0 * 4,			/* r4 */
  1 * 4,			/* r5 */
  2 * 4,			/* r6 */
  8 * 4,			/* r7 */
  9 * 4,			/* r8 */
  10 * 4,			/* r9 */
  11 * 4,			/* r10 */
  12 * 4,			/* r11 */
  13 * 4,			/* r12 */
  21 * 4,			/* fp */
  22 * 4,			/* lr */
  -1 * 4,			/* sp */
  16 * 4,			/* psw */
  -1 * 4,			/* cbr */
  23 * 4,			/* spi */
  20 * 4,			/* spu */
  19 * 4,			/* bpc */
  17 * 4,			/* pc */
  15 * 4,			/* accl */
  14 * 4			/* acch */
};

struct m32r_frame_cache
{
  CORE_ADDR base, pc;
  struct trad_frame_saved_reg *saved_regs;
};

static struct m32r_frame_cache *
m32r_linux_sigtramp_frame_cache (struct frame_info *next_frame,
				 void **this_cache)
{
  struct m32r_frame_cache *cache;
  CORE_ADDR sigcontext_addr, addr;
  int regnum;

  if ((*this_cache) != NULL)
    return (*this_cache);
  cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
  (*this_cache) = cache;
  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);

  cache->base = frame_unwind_register_unsigned (next_frame, M32R_SP_REGNUM);
  sigcontext_addr = cache->base + 4;

  cache->pc = frame_pc_unwind (next_frame);
  addr = m32r_linux_sigtramp_start (cache->pc, next_frame);
  if (addr == 0)
    {
      /* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
         accordingly.  */
      addr = m32r_linux_rt_sigtramp_start (cache->pc, next_frame);
      if (addr)
	sigcontext_addr += 128;
      else
	addr = frame_func_unwind (next_frame, NORMAL_FRAME);
    }
  cache->pc = addr;

  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);

  for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++)
    {
      if (m32r_linux_sc_reg_offset[regnum] >= 0)
	cache->saved_regs[regnum].addr =
	  sigcontext_addr + m32r_linux_sc_reg_offset[regnum];
    }

  return cache;
}

static void
m32r_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
				   void **this_cache,
				   struct frame_id *this_id)
{
  struct m32r_frame_cache *cache =
    m32r_linux_sigtramp_frame_cache (next_frame, this_cache);

  (*this_id) = frame_id_build (cache->base, cache->pc);
}

static void
m32r_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
					 void **this_cache,
					 int regnum, int *optimizedp,
					 enum lval_type *lvalp,
					 CORE_ADDR *addrp,
					 int *realnump, gdb_byte *valuep)
{
  struct m32r_frame_cache *cache =
    m32r_linux_sigtramp_frame_cache (next_frame, this_cache);

  trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
				optimizedp, lvalp, addrp, realnump, valuep);
}

static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
  SIGTRAMP_FRAME,
  m32r_linux_sigtramp_frame_this_id,
  m32r_linux_sigtramp_frame_prev_register
};

static const struct frame_unwind *
m32r_linux_sigtramp_frame_sniffer (struct frame_info *next_frame)
{
  CORE_ADDR pc = frame_pc_unwind (next_frame);
  char *name;

  find_pc_partial_function (pc, &name, NULL, NULL);
  if (m32r_linux_pc_in_sigtramp (pc, name, next_frame))
    return &m32r_linux_sigtramp_frame_unwind;

  return NULL;
}

/* Mapping between the registers in `struct pt_regs'
   format and GDB's register array layout.  */

static int m32r_pt_regs_offset[] = {
  4 * 4,			/* r0 */
  4 * 5,			/* r1 */
  4 * 6,			/* r2 */
  4 * 7,			/* r3 */
  4 * 0,			/* r4 */
  4 * 1,			/* r5 */
  4 * 2,			/* r6 */
  4 * 8,			/* r7 */
  4 * 9,			/* r8 */
  4 * 10,			/* r9 */
  4 * 11,			/* r10 */
  4 * 12,			/* r11 */
  4 * 13,			/* r12 */
  4 * 24,			/* fp */
  4 * 25,			/* lr */
  4 * 23,			/* sp */
  4 * 19,			/* psw */
  4 * 19,			/* cbr */
  4 * 26,			/* spi */
  4 * 23,			/* spu */
  4 * 22,			/* bpc */
  4 * 20,			/* pc */
  4 * 16,			/* accl */
  4 * 15			/* acch */
};

#define PSW_OFFSET (4 * 19)
#define BBPSW_OFFSET (4 * 21)
#define SPU_OFFSET (4 * 23)
#define SPI_OFFSET (4 * 26)

static void
m32r_linux_supply_gregset (const struct regset *regset,
			   struct regcache *regcache, int regnum,
			   const void *gregs, size_t size)
{
  const char *regs = gregs;
  unsigned long psw, bbpsw;
  int i;

  psw = *((unsigned long *) (regs + PSW_OFFSET));
  bbpsw = *((unsigned long *) (regs + BBPSW_OFFSET));

  for (i = 0; i < sizeof (m32r_pt_regs_offset) / 4; i++)
    {
      if (regnum != -1 && regnum != i)
	continue;

      switch (i)
	{
	case PSW_REGNUM:
	  *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
	    ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
	  break;
	case CBR_REGNUM:
	  *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
	    ((psw >> 8) & 1);
	  break;
	case M32R_SP_REGNUM:
	  if (psw & 0x8000)
	    *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
	      *((unsigned long *) (regs + SPU_OFFSET));
	  else
	    *((unsigned long *) (regs + m32r_pt_regs_offset[i])) =
	      *((unsigned long *) (regs + SPI_OFFSET));
	  break;
	}

      regcache_raw_supply (regcache, i,
			   regs + m32r_pt_regs_offset[i]);
    }
}

static struct regset m32r_linux_gregset = {
  NULL, m32r_linux_supply_gregset
};

static const struct regset *
m32r_linux_regset_from_core_section (struct gdbarch *core_arch,
				     const char *sect_name, size_t sect_size)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
  if (strcmp (sect_name, ".reg") == 0)
    return &m32r_linux_gregset;
  return NULL;
}

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

  /* Since EVB register is not available for native debug, we reduce
     the number of registers.  */
  set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);

  frame_unwind_append_sniffer (gdbarch, m32r_linux_sigtramp_frame_sniffer);

  /* GNU/Linux uses SVR4-style shared libraries.  */
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);

  /* Core file support.  */
  set_gdbarch_regset_from_core_section
    (gdbarch, m32r_linux_regset_from_core_section);

  /* Enable TLS support.  */
  set_gdbarch_fetch_tls_load_module_address (gdbarch,
                                             svr4_fetch_objfile_link_map);
}

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

void
_initialize_m32r_linux_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
			  m32r_linux_init_abi);
}
Commit	Line	Data
9b32d526 KI	1	/* Target-dependent code for GNU/Linux m32r.
9b32d526 KI	2
9b254dd1	3	Copyright (C) 2004, 2007, 2008 Free Software Foundation, Inc.
9b32d526 KI	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
9b32d526 KI	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
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
9b32d526 KI	19
	20	#include "defs.h"
	21	#include "gdbcore.h"
	22	#include "frame.h"
	23	#include "value.h"
	24	#include "regcache.h"
	25	#include "inferior.h"
	26	#include "osabi.h"
	27	#include "reggroups.h"
9b098f24	28	#include "regset.h"
9b32d526 KI	29
	30	#include "gdb_string.h"
	31
	32	#include "glibc-tdep.h"
	33	#include "solib-svr4.h"
982e9687	34	#include "symtab.h"
9b32d526 KI	35
	36	#include "trad-frame.h"
	37	#include "frame-unwind.h"
	38
	39	#include "m32r-tdep.h"
	40	\f
	41
	42	/* Recognizing signal handler frames. */
	43
	44	/* GNU/Linux has two flavors of signals. Normal signal handlers, and
	45	"realtime" (RT) signals. The RT signals can provide additional
	46	information to the signal handler if the SA_SIGINFO flag is set
	47	when establishing a signal handler using `sigaction'. It is not
	48	unlikely that future versions of GNU/Linux will support SA_SIGINFO
	49	for normal signals too. */
	50
	51	/* When the m32r Linux kernel calls a signal handler and the
	52	SA_RESTORER flag isn't set, the return address points to a bit of
	53	code on the stack. This function returns whether the PC appears to
	54	be within this bit of code.
	55
	56	The instruction sequence for normal signals is
	57	ldi r7, #__NR_sigreturn
	58	trap #2
	59	or 0x67 0x77 0x10 0xf2.
	60
	61	Checking for the code sequence should be somewhat reliable, because
	62	the effect is to call the system call sigreturn. This is unlikely
	63	to occur anywhere other than in a signal trampoline.
	64
	65	It kind of sucks that we have to read memory from the process in
	66	order to identify a signal trampoline, but there doesn't seem to be
	67	any other way. Therefore we only do the memory reads if no
	68	function name could be identified, which should be the case since
	69	the code is on the stack.
	70
	71	Detection of signal trampolines for handlers that set the
	72	SA_RESTORER flag is in general not possible. Unfortunately this is
	73	what the GNU C Library has been doing for quite some time now.
	74	However, as of version 2.1.2, the GNU C Library uses signal
	75	trampolines (named __restore and __restore_rt) that are identical
	76	to the ones used by the kernel. Therefore, these trampolines are
	77	supported too. */
	78
16ac4ab5	79	static const gdb_byte linux_sigtramp_code[] = {
9b32d526 KI	80	0x67, 0x77, 0x10, 0xf2,
	81	};
	82
	83	/* If PC is in a sigtramp routine, return the address of the start of
	84	the routine. Otherwise, return 0. */
	85
	86	static CORE_ADDR
	87	m32r_linux_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
	88	{
16ac4ab5	89	gdb_byte buf[4];
9b32d526 KI	90
	91	/* We only recognize a signal trampoline if PC is at the start of
	92	one of the instructions. We optimize for finding the PC at the
	93	start of the instruction sequence, as will be the case when the
	94	trampoline is not the first frame on the stack. We assume that
	95	in the case where the PC is not at the start of the instruction
	96	sequence, there will be a few trailing readable bytes on the
	97	stack. */
	98
	99	if (pc % 2 != 0)
	100	{
	101	if (!safe_frame_unwind_memory (next_frame, pc, buf, 2))
	102	return 0;
	103
	104	if (memcmp (buf, linux_sigtramp_code, 2) == 0)
	105	pc -= 2;
	106	else
	107	return 0;
	108	}
	109
	110	if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
	111	return 0;
	112
	113	if (memcmp (buf, linux_sigtramp_code, 4) != 0)
	114	return 0;
	115
	116	return pc;
	117	}
	118
	119	/* This function does the same for RT signals. Here the instruction
	120	sequence is
	121	ldi r7, #__NR_rt_sigreturn
	122	trap #2
	123	or 0x97 0xf0 0x00 0xad 0x10 0xf2 0xf0 0x00.
	124
	125	The effect is to call the system call rt_sigreturn. */
	126
16ac4ab5	127	static const gdb_byte linux_rt_sigtramp_code[] = {
9b32d526 KI	128	0x97, 0xf0, 0x00, 0xad, 0x10, 0xf2, 0xf0, 0x00,
	129	};
	130
	131	/* If PC is in a RT sigtramp routine, return the address of the start
	132	of the routine. Otherwise, return 0. */
	133
	134	static CORE_ADDR
	135	m32r_linux_rt_sigtramp_start (CORE_ADDR pc, struct frame_info *next_frame)
	136	{
16ac4ab5	137	gdb_byte buf[4];
9b32d526 KI	138
	139	/* We only recognize a signal trampoline if PC is at the start of
	140	one of the instructions. We optimize for finding the PC at the
	141	start of the instruction sequence, as will be the case when the
	142	trampoline is not the first frame on the stack. We assume that
	143	in the case where the PC is not at the start of the instruction
	144	sequence, there will be a few trailing readable bytes on the
	145	stack. */
	146
	147	if (pc % 2 != 0)
	148	return 0;
	149
	150	if (!safe_frame_unwind_memory (next_frame, pc, buf, 4))
	151	return 0;
	152
	153	if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
	154	{
	155	if (!safe_frame_unwind_memory (next_frame, pc + 4, buf, 4))
	156	return 0;
	157
	158	if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
	159	return pc;
	160	}
	161	else if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0)
	162	{
	163	if (!safe_frame_unwind_memory (next_frame, pc - 4, buf, 4))
	164	return 0;
	165
	166	if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
	167	return pc - 4;
	168	}
	169
	170	return 0;
	171	}
	172
	173	static int
	174	m32r_linux_pc_in_sigtramp (CORE_ADDR pc, char *name,
	175	struct frame_info *next_frame)
	176	{
	177	/* If we have NAME, we can optimize the search. The trampolines are
	178	named __restore and __restore_rt. However, they aren't dynamically
	179	exported from the shared C library, so the trampoline may appear to
	180	be part of the preceding function. This should always be sigaction,
	181	__sigaction, or __libc_sigaction (all aliases to the same function). */
	182	if (name == NULL \|\| strstr (name, "sigaction") != NULL)
	183	return (m32r_linux_sigtramp_start (pc, next_frame) != 0
	184	\|\| m32r_linux_rt_sigtramp_start (pc, next_frame) != 0);
	185
	186	return (strcmp ("__restore", name) == 0
	187	\|\| strcmp ("__restore_rt", name) == 0);
	188	}
	189
	190	/* From <asm/sigcontext.h>. */
	191	static int m32r_linux_sc_reg_offset[] = {
	192	4 * 4, /* r0 */
	193	5 * 4, /* r1 */
	194	6 * 4, /* r2 */
	195	7 * 4, /* r3 */
	196	0 * 4, /* r4 */
	197	1 * 4, /* r5 */
	198	2 * 4, /* r6 */
	199	8 * 4, /* r7 */
	200	9 * 4, /* r8 */
	201	10 * 4, /* r9 */
202	11 * 4, /* r10 */
203	12 * 4, /* r11 */
204	13 * 4, /* r12 */
205	21 * 4, /* fp */
206	22 * 4, /* lr */
207	-1 * 4, /* sp */
208	16 * 4, /* psw */
209	-1 * 4, /* cbr */
210	23 * 4, /* spi */
211	20 * 4, /* spu */
212	19 * 4, /* bpc */
213	17 * 4, /* pc */
214	15 * 4, /* accl */
215	14 * 4 /* acch */
216	};
217
218	struct m32r_frame_cache
219	{
220	CORE_ADDR base, pc;
221	struct trad_frame_saved_reg *saved_regs;
222	};
223
224	static struct m32r_frame_cache *
225	m32r_linux_sigtramp_frame_cache (struct frame_info *next_frame,
226	void **this_cache)
227	{
228	struct m32r_frame_cache *cache;
229	CORE_ADDR sigcontext_addr, addr;
230	int regnum;
231
232	if ((*this_cache) != NULL)
233	return (*this_cache);
234	cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
235	(*this_cache) = cache;
236	cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
237
238	cache->base = frame_unwind_register_unsigned (next_frame, M32R_SP_REGNUM);
239	sigcontext_addr = cache->base + 4;
240
241	cache->pc = frame_pc_unwind (next_frame);
242	addr = m32r_linux_sigtramp_start (cache->pc, next_frame);
243	if (addr == 0)
244	{
245	/* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
246	accordingly. */
247	addr = m32r_linux_rt_sigtramp_start (cache->pc, next_frame);
248	if (addr)
249	sigcontext_addr += 128;
250	else
93d42b30	251	addr = frame_func_unwind (next_frame, NORMAL_FRAME);
9b32d526 KI	252	}
	253	cache->pc = addr;
	254
	255	cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
	256
	257	for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++)
	258	{
	259	if (m32r_linux_sc_reg_offset[regnum] >= 0)
	260	cache->saved_regs[regnum].addr =
	261	sigcontext_addr + m32r_linux_sc_reg_offset[regnum];
	262	}
	263
	264	return cache;
	265	}
	266
	267	static void
	268	m32r_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
	269	void **this_cache,
	270	struct frame_id *this_id)
	271	{
	272	struct m32r_frame_cache *cache =
	273	m32r_linux_sigtramp_frame_cache (next_frame, this_cache);
	274
	275	(*this_id) = frame_id_build (cache->base, cache->pc);
	276	}
	277
	278	static void
	279	m32r_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
	280	void **this_cache,
	281	int regnum, int *optimizedp,
	282	enum lval_type *lvalp,
	283	CORE_ADDR *addrp,
16ac4ab5	284	int realnump, gdb_byte valuep)
9b32d526 KI	285	{
	286	struct m32r_frame_cache *cache =
	287	m32r_linux_sigtramp_frame_cache (next_frame, this_cache);
	288
	289	trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
	290	optimizedp, lvalp, addrp, realnump, valuep);
	291	}
	292
	293	static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
	294	SIGTRAMP_FRAME,
	295	m32r_linux_sigtramp_frame_this_id,
	296	m32r_linux_sigtramp_frame_prev_register
	297	};
	298
	299	static const struct frame_unwind *
	300	m32r_linux_sigtramp_frame_sniffer (struct frame_info *next_frame)
	301	{
	302	CORE_ADDR pc = frame_pc_unwind (next_frame);
	303	char *name;
	304
	305	find_pc_partial_function (pc, &name, NULL, NULL);
	306	if (m32r_linux_pc_in_sigtramp (pc, name, next_frame))
	307	return &m32r_linux_sigtramp_frame_unwind;
	308
	309	return NULL;
	310	}
	311
9b098f24 KI	312	/* Mapping between the registers in `struct pt_regs'
	313	format and GDB's register array layout. */
	314
	315	static int m32r_pt_regs_offset[] = {
	316	4 * 4, /* r0 */
	317	4 * 5, /* r1 */
	318	4 * 6, /* r2 */
	319	4 * 7, /* r3 */
	320	4 * 0, /* r4 */
	321	4 * 1, /* r5 */
	322	4 * 2, /* r6 */
	323	4 * 8, /* r7 */
	324	4 * 9, /* r8 */
	325	4 * 10, /* r9 */
	326	4 * 11, /* r10 */
	327	4 * 12, /* r11 */
	328	4 * 13, /* r12 */
	329	4 * 24, /* fp */
	330	4 * 25, /* lr */
	331	4 * 23, /* sp */
	332	4 * 19, /* psw */
	333	4 * 19, /* cbr */
	334	4 * 26, /* spi */
	335	4 * 23, /* spu */
	336	4 * 22, /* bpc */
	337	4 * 20, /* pc */
	338	4 * 16, /* accl */
	339	4 * 15 /* acch */
	340	};
	341
	342	#define PSW_OFFSET (4 * 19)
	343	#define BBPSW_OFFSET (4 * 21)
	344	#define SPU_OFFSET (4 * 23)
	345	#define SPI_OFFSET (4 * 26)
	346
	347	static void
	348	m32r_linux_supply_gregset (const struct regset *regset,
	349	struct regcache *regcache, int regnum,
	350	const void *gregs, size_t size)
	351	{
	352	const char *regs = gregs;
	353	unsigned long psw, bbpsw;
	354	int i;
	355
	356	psw = ((unsigned long ) (regs + PSW_OFFSET));
	357	bbpsw = ((unsigned long ) (regs + BBPSW_OFFSET));
	358
	359	for (i = 0; i < sizeof (m32r_pt_regs_offset) / 4; i++)
	360	{
	361	if (regnum != -1 && regnum != i)
	362	continue;
	363
	364	switch (i)
	365	{
	366	case PSW_REGNUM:
	367	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
	368	((0x00c1 & bbpsw) << 8) \| ((0xc100 & psw) >> 8);
	369	break;
	370	case CBR_REGNUM:
	371	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
	372	((psw >> 8) & 1);
	373	break;
	374	case M32R_SP_REGNUM:
	375	if (psw & 0x8000)
376	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
377	((unsigned long ) (regs + SPU_OFFSET));
378	else
379	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
380	((unsigned long ) (regs + SPI_OFFSET));
381	break;
382	}
383
9c9acae0	384	regcache_raw_supply (regcache, i,
9b098f24 KI	385	regs + m32r_pt_regs_offset[i]);
	386	}
	387	}
	388
	389	static struct regset m32r_linux_gregset = {
	390	NULL, m32r_linux_supply_gregset
	391	};
	392
	393	static const struct regset *
	394	m32r_linux_regset_from_core_section (struct gdbarch *core_arch,
	395	const char *sect_name, size_t sect_size)
	396	{
	397	struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
	398	if (strcmp (sect_name, ".reg") == 0)
	399	return &m32r_linux_gregset;
	400	return NULL;
	401	}
	402
9b32d526 KI	403	static void
	404	m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	405	{
	406	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	407
	408	/* Since EVB register is not available for native debug, we reduce
	409	the number of registers. */
	410	set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
	411
	412	frame_unwind_append_sniffer (gdbarch, m32r_linux_sigtramp_frame_sniffer);
	413
	414	/* GNU/Linux uses SVR4-style shared libraries. */
982e9687	415	set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
9b32d526 KI	416	set_solib_svr4_fetch_link_map_offsets
9b32d526 KI	417	(gdbarch, svr4_ilp32_fetch_link_map_offsets);
9b098f24 KI	418
	419	/* Core file support. */
	420	set_gdbarch_regset_from_core_section
	421	(gdbarch, m32r_linux_regset_from_core_section);
b2756930 KB	422
	423	/* Enable TLS support. */
	424	set_gdbarch_fetch_tls_load_module_address (gdbarch,
	425	svr4_fetch_objfile_link_map);
9b32d526 KI	426	}
	427
	428	/* Provide a prototype to silence -Wmissing-prototypes. */
	429	extern void _initialize_m32r_linux_tdep (void);
	430
	431	void
	432	_initialize_m32r_linux_tdep (void)
	433	{
	434	gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
	435	m32r_linux_init_abi);
	436	}