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
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
79static 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
86static CORE_ADDR
87m32r_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
127static 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
134static CORE_ADDR
135m32r_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
173static int
174m32r_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>.  */
191static 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
218struct m32r_frame_cache
219{
220  CORE_ADDR base, pc;
221  struct trad_frame_saved_reg *saved_regs;
222};
223
224static struct m32r_frame_cache *
225m32r_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
267static void
268m32r_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
278static void
279m32r_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
293static 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
299static const struct frame_unwind *
300m32r_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
312static void
313m32r_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.  */
329extern void _initialize_m32r_linux_tdep (void);
330
331void
332_initialize_m32r_linux_tdep (void)
333{
334  gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
335			  m32r_linux_init_abi);
336}
337