[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 "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;
}

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);
}

/* 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"
	30
	31	#include "gdb_string.h"
	32
	33	#include "glibc-tdep.h"
	34	#include "solib-svr4.h"
	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
79	static const unsigned char linux_sigtramp_code[] = {
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	{
89	unsigned char buf[4];
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
127	static const unsigned char linux_rt_sigtramp_code[] = {
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	{
137	unsigned char buf[4];
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
251	addr = frame_func_unwind (next_frame);
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,
284	int realnump, void valuep)
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
312	static void
313	m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
314	{
315	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
316
317	/* Since EVB register is not available for native debug, we reduce
318	the number of registers. */
319	set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
320
321	frame_unwind_append_sniffer (gdbarch, m32r_linux_sigtramp_frame_sniffer);
322
323	/* GNU/Linux uses SVR4-style shared libraries. */
324	set_solib_svr4_fetch_link_map_offsets
325	(gdbarch, svr4_ilp32_fetch_link_map_offsets);
326	}
327
328	/* Provide a prototype to silence -Wmissing-prototypes. */
329	extern void _initialize_m32r_linux_tdep (void);
330
331	void
332	_initialize_m32r_linux_tdep (void)
333	{
334	gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
335	m32r_linux_init_abi);
336	}