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

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

   Copyright (C) 2004, 2007, 2008, 2009 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 *this_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 (this_frame, pc, buf, 2))
	return 0;

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

  if (!safe_frame_unwind_memory (this_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 *this_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 (this_frame, pc, buf, 4))
    return 0;

  if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
    {
      if (!safe_frame_unwind_memory (this_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 (this_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 *this_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, this_frame) != 0
	    || m32r_linux_rt_sigtramp_start (pc, this_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 *this_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 (this_frame);

  cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
  sigcontext_addr = cache->base + 4;

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

  cache->saved_regs = trad_frame_alloc_saved_regs (this_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 *this_frame,
				   void **this_cache,
				   struct frame_id *this_id)
{
  struct m32r_frame_cache *cache =
    m32r_linux_sigtramp_frame_cache (this_frame, this_cache);

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

static struct value *
m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
					 void **this_cache, int regnum)
{
  struct m32r_frame_cache *cache =
    m32r_linux_sigtramp_frame_cache (this_frame, this_cache);

  return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
}

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

  find_pc_partial_function (pc, &name, NULL, NULL);
  if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
    return 1;

  return 0;
}

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

/* 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_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);

  /* 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
0fb0cc75	3	Copyright (C) 2004, 2007, 2008, 2009 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
94afd7a6	87	m32r_linux_sigtramp_start (CORE_ADDR pc, struct frame_info *this_frame)
9b32d526	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	{
94afd7a6	101	if (!safe_frame_unwind_memory (this_frame, pc, buf, 2))
9b32d526 KI	102	return 0;
	103
	104	if (memcmp (buf, linux_sigtramp_code, 2) == 0)
	105	pc -= 2;
	106	else
	107	return 0;
	108	}
	109
94afd7a6	110	if (!safe_frame_unwind_memory (this_frame, pc, buf, 4))
9b32d526 KI	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
94afd7a6	135	m32r_linux_rt_sigtramp_start (CORE_ADDR pc, struct frame_info *this_frame)
9b32d526	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
94afd7a6	150	if (!safe_frame_unwind_memory (this_frame, pc, buf, 4))
9b32d526 KI	151	return 0;
	152
	153	if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0)
	154	{
94afd7a6	155	if (!safe_frame_unwind_memory (this_frame, pc + 4, buf, 4))
9b32d526 KI	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	{
94afd7a6	163	if (!safe_frame_unwind_memory (this_frame, pc - 4, buf, 4))
9b32d526 KI	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,
94afd7a6	175	struct frame_info *this_frame)
9b32d526 KI	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)
94afd7a6 UW	183	return (m32r_linux_sigtramp_start (pc, this_frame) != 0
94afd7a6 UW	184	\|\| m32r_linux_rt_sigtramp_start (pc, this_frame) != 0);
9b32d526 KI	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 *
94afd7a6	225	m32r_linux_sigtramp_frame_cache (struct frame_info *this_frame,
9b32d526 KI	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;
94afd7a6	236	cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
9b32d526	237
94afd7a6	238	cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
9b32d526 KI	239	sigcontext_addr = cache->base + 4;
9b32d526 KI	240
94afd7a6 UW	241	cache->pc = get_frame_pc (this_frame);
94afd7a6 UW	242	addr = m32r_linux_sigtramp_start (cache->pc, this_frame);
9b32d526 KI	243	if (addr == 0)
	244	{
	245	/* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
	246	accordingly. */
94afd7a6	247	addr = m32r_linux_rt_sigtramp_start (cache->pc, this_frame);
9b32d526 KI	248	if (addr)
	249	sigcontext_addr += 128;
	250	else
94afd7a6	251	addr = get_frame_func (this_frame);
9b32d526 KI	252	}
	253	cache->pc = addr;
	254
94afd7a6	255	cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
9b32d526 KI	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
94afd7a6	268	m32r_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
9b32d526 KI	269	void **this_cache,
	270	struct frame_id *this_id)
	271	{
	272	struct m32r_frame_cache *cache =
94afd7a6	273	m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
9b32d526 KI	274
	275	(*this_id) = frame_id_build (cache->base, cache->pc);
	276	}
	277
94afd7a6 UW	278	static struct value *
	279	m32r_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
	280	void **this_cache, int regnum)
9b32d526 KI	281	{
9b32d526 KI	282	struct m32r_frame_cache *cache =
94afd7a6	283	m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
9b32d526	284
94afd7a6	285	return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
9b32d526 KI	286	}
9b32d526 KI	287
94afd7a6 UW	288	static int
	289	m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
	290	struct frame_info *this_frame,
	291	void **this_cache)
9b32d526	292	{
94afd7a6	293	CORE_ADDR pc = get_frame_pc (this_frame);
9b32d526 KI	294	char *name;
	295
	296	find_pc_partial_function (pc, &name, NULL, NULL);
94afd7a6 UW	297	if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
94afd7a6 UW	298	return 1;
9b32d526	299
94afd7a6	300	return 0;
9b32d526 KI	301	}
9b32d526 KI	302
94afd7a6 UW	303	static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
	304	SIGTRAMP_FRAME,
	305	m32r_linux_sigtramp_frame_this_id,
	306	m32r_linux_sigtramp_frame_prev_register,
	307	NULL,
	308	m32r_linux_sigtramp_frame_sniffer
	309	};
	310
9b098f24 KI	311	/* Mapping between the registers in `struct pt_regs'
	312	format and GDB's register array layout. */
	313
	314	static int m32r_pt_regs_offset[] = {
	315	4 * 4, /* r0 */
	316	4 * 5, /* r1 */
	317	4 * 6, /* r2 */
	318	4 * 7, /* r3 */
	319	4 * 0, /* r4 */
	320	4 * 1, /* r5 */
	321	4 * 2, /* r6 */
	322	4 * 8, /* r7 */
	323	4 * 9, /* r8 */
	324	4 * 10, /* r9 */
	325	4 * 11, /* r10 */
	326	4 * 12, /* r11 */
	327	4 * 13, /* r12 */
	328	4 * 24, /* fp */
	329	4 * 25, /* lr */
	330	4 * 23, /* sp */
	331	4 * 19, /* psw */
	332	4 * 19, /* cbr */
	333	4 * 26, /* spi */
	334	4 * 23, /* spu */
	335	4 * 22, /* bpc */
	336	4 * 20, /* pc */
	337	4 * 16, /* accl */
	338	4 * 15 /* acch */
	339	};
	340
	341	#define PSW_OFFSET (4 * 19)
	342	#define BBPSW_OFFSET (4 * 21)
	343	#define SPU_OFFSET (4 * 23)
	344	#define SPI_OFFSET (4 * 26)
	345
	346	static void
	347	m32r_linux_supply_gregset (const struct regset *regset,
	348	struct regcache *regcache, int regnum,
	349	const void *gregs, size_t size)
	350	{
	351	const char *regs = gregs;
	352	unsigned long psw, bbpsw;
	353	int i;
	354
	355	psw = ((unsigned long ) (regs + PSW_OFFSET));
	356	bbpsw = ((unsigned long ) (regs + BBPSW_OFFSET));
	357
	358	for (i = 0; i < sizeof (m32r_pt_regs_offset) / 4; i++)
	359	{
	360	if (regnum != -1 && regnum != i)
	361	continue;
	362
	363	switch (i)
	364	{
	365	case PSW_REGNUM:
	366	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
	367	((0x00c1 & bbpsw) << 8) \| ((0xc100 & psw) >> 8);
	368	break;
	369	case CBR_REGNUM:
	370	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
	371	((psw >> 8) & 1);
	372	break;
	373	case M32R_SP_REGNUM:
	374	if (psw & 0x8000)
375	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
376	((unsigned long ) (regs + SPU_OFFSET));
377	else
378	((unsigned long ) (regs + m32r_pt_regs_offset[i])) =
379	((unsigned long ) (regs + SPI_OFFSET));
380	break;
381	}
382
9c9acae0	383	regcache_raw_supply (regcache, i,
9b098f24 KI	384	regs + m32r_pt_regs_offset[i]);
	385	}
	386	}
	387
	388	static struct regset m32r_linux_gregset = {
	389	NULL, m32r_linux_supply_gregset
	390	};
	391
	392	static const struct regset *
	393	m32r_linux_regset_from_core_section (struct gdbarch *core_arch,
	394	const char *sect_name, size_t sect_size)
	395	{
	396	struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
	397	if (strcmp (sect_name, ".reg") == 0)
	398	return &m32r_linux_gregset;
	399	return NULL;
	400	}
	401
9b32d526 KI	402	static void
	403	m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	404	{
	405	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	406
	407	/* Since EVB register is not available for native debug, we reduce
	408	the number of registers. */
	409	set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
	410
94afd7a6	411	frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
9b32d526 KI	412
9b32d526 KI	413	/* GNU/Linux uses SVR4-style shared libraries. */
982e9687	414	set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
9b32d526 KI	415	set_solib_svr4_fetch_link_map_offsets
9b32d526 KI	416	(gdbarch, svr4_ilp32_fetch_link_map_offsets);
9b098f24 KI	417
	418	/* Core file support. */
	419	set_gdbarch_regset_from_core_section
	420	(gdbarch, m32r_linux_regset_from_core_section);
b2756930 KB	421
	422	/* Enable TLS support. */
	423	set_gdbarch_fetch_tls_load_module_address (gdbarch,
	424	svr4_fetch_objfile_link_map);
9b32d526 KI	425	}
	426
	427	/* Provide a prototype to silence -Wmissing-prototypes. */
	428	extern void _initialize_m32r_linux_tdep (void);
	429
	430	void
	431	_initialize_m32r_linux_tdep (void)
	432	{
	433	gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
	434	m32r_linux_init_abi);
	435	}