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

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

   Copyright 2004 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

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