GDB (xrefs)
/tmp/gdb-7.10/gdb/m32r-linux-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for GNU/Linux m32r.
2 
3  Copyright (C) 2004-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
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"
28 #include "regset.h"
29 
30 #include "glibc-tdep.h"
31 #include "solib-svr4.h"
32 #include "symtab.h"
33 
34 #include "trad-frame.h"
35 #include "frame-unwind.h"
36 
37 #include "m32r-tdep.h"
38 #include "linux-tdep.h"
39 
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 
79 static const gdb_byte 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
88 {
89  gdb_byte 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 (this_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 (this_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 
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
136 {
137  gdb_byte 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 (this_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 (this_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 (this_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
175  struct frame_info *this_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, this_frame) != 0
184  || m32r_linux_rt_sigtramp_start (pc, this_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 
219 {
222 };
223 
224 static struct m32r_frame_cache *
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 (this_frame);
237 
238  cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
239  sigcontext_addr = cache->base + 4;
240 
241  cache->pc = get_frame_pc (this_frame);
242  addr = m32r_linux_sigtramp_start (cache->pc, this_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, this_frame);
248  if (addr)
249  sigcontext_addr += 128;
250  else
251  addr = get_frame_func (this_frame);
252  }
253  cache->pc = addr;
254 
255  cache->saved_regs = trad_frame_alloc_saved_regs (this_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
269  void **this_cache,
270  struct frame_id *this_id)
271 {
272  struct m32r_frame_cache *cache =
273  m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
274 
275  (*this_id) = frame_id_build (cache->base, cache->pc);
276 }
277 
278 static struct value *
280  void **this_cache, int regnum)
281 {
282  struct m32r_frame_cache *cache =
283  m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
284 
285  return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
286 }
287 
288 static int
290  struct frame_info *this_frame,
291  void **this_cache)
292 {
293  CORE_ADDR pc = get_frame_pc (this_frame);
294  const char *name;
295 
296  find_pc_partial_function (pc, &name, NULL, NULL);
297  if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
298  return 1;
299 
300  return 0;
301 }
302 
303 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = {
308  NULL,
310 };
311 
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 #define M32R_LINUX_GREGS_SIZE (4 * 28)
348 
349 static void
351  struct regcache *regcache, int regnum,
352  const void *gregs, size_t size)
353 {
354  const gdb_byte *regs = gregs;
355  enum bfd_endian byte_order =
357  ULONGEST psw, bbpsw;
358  gdb_byte buf[4];
359  const gdb_byte *p;
360  int i;
361 
362  psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order);
363  bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order);
364  psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
365 
366  for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
367  {
368  if (regnum != -1 && regnum != i)
369  continue;
370 
371  switch (i)
372  {
373  case PSW_REGNUM:
374  store_unsigned_integer (buf, 4, byte_order, psw);
375  p = buf;
376  break;
377  case CBR_REGNUM:
378  store_unsigned_integer (buf, 4, byte_order, psw & 1);
379  p = buf;
380  break;
381  case M32R_SP_REGNUM:
382  p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET);
383  break;
384  default:
385  p = regs + m32r_pt_regs_offset[i];
386  }
387 
388  regcache_raw_supply (regcache, i, p);
389  }
390 }
391 
392 static void
394  const struct regcache *regcache,
395  int regnum, void *gregs, size_t size)
396 {
397  gdb_byte *regs = gregs;
398  int i;
399  enum bfd_endian byte_order =
401  ULONGEST psw;
402  gdb_byte buf[4];
403 
404  regcache_raw_collect (regcache, PSW_REGNUM, buf);
405  psw = extract_unsigned_integer (buf, 4, byte_order);
406 
407  for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
408  {
409  if (regnum != -1 && regnum != i)
410  continue;
411 
412  switch (i)
413  {
414  case PSW_REGNUM:
415  store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order,
416  (psw & 0xc1) << 8);
417  store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order,
418  (psw >> 8) & 0xc1);
419  break;
420  case CBR_REGNUM:
421  break;
422  case M32R_SP_REGNUM:
423  regcache_raw_collect (regcache, i, regs
424  + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET));
425  break;
426  default:
427  regcache_raw_collect (regcache, i,
428  regs + m32r_pt_regs_offset[i]);
429  }
430  }
431 }
432 
433 static const struct regset m32r_linux_gregset = {
434  NULL,
436 };
437 
438 static void
441  void *cb_data,
442  const struct regcache *regcache)
443 {
444  cb (".reg", M32R_LINUX_GREGS_SIZE, &m32r_linux_gregset, NULL, cb_data);
445 }
446 
447 static void
449 {
450  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
451 
452  linux_init_abi (info, gdbarch);
453 
454  /* Since EVB register is not available for native debug, we reduce
455  the number of registers. */
456  set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1);
457 
458  frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind);
459 
460  /* GNU/Linux uses SVR4-style shared libraries. */
464 
465  /* Core file support. */
468 
469  /* Enable TLS support. */
472 }
473 
474 /* Provide a prototype to silence -Wmissing-prototypes. */
475 extern void _initialize_m32r_linux_tdep (void);
476 
477 void
479 {
480  gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
482 }
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static void m32r_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
static CORE_ADDR m32r_linux_sigtramp_start(CORE_ADDR pc, struct frame_info *this_frame)
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
void _initialize_m32r_linux_tdep(void)
bfd_vma CORE_ADDR
Definition: common-types.h:41
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
Definition: gdbarch.c:2822
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:135
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
static void m32r_linux_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t size)
static void m32r_linux_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t size)
struct m32c_reg * pc
Definition: m32c-tdep.c:111
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2427
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3149
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static struct value * m32r_linux_sigtramp_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1573
Definition: regset.h:34
static CORE_ADDR m32r_linux_rt_sigtramp_start(CORE_ADDR pc, struct frame_info *this_frame)
static int m32r_linux_pc_in_sigtramp(CORE_ADDR pc, const char *name, struct frame_info *this_frame)
const char *const name
Definition: aarch64-tdep.c:68
static int m32r_linux_sigtramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
static const gdb_byte linux_rt_sigtramp_code[]
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
Definition: minsyms.c:1394
int safe_frame_unwind_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
Definition: frame.c:2525
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
#define M32R_LINUX_GREGS_SIZE
#define PSW_OFFSET
#define M32R_NUM_REGS
Definition: m32r-tdep.h:48
static int m32r_pt_regs_offset[]
int regnum
Definition: aarch64-tdep.c:69
#define BBPSW_OFFSET
void( iterate_over_regset_sections_cb)(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: gdbarch.h:98
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
Definition: value.c:172
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
bfd_byte gdb_byte
Definition: common-types.h:38
struct trad_frame_saved_reg * saved_regs
static int m32r_linux_sc_reg_offset[]
static void m32r_linux_sigtramp_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
static struct m32r_frame_cache * m32r_linux_sigtramp_frame_cache(struct frame_info *this_frame, void **this_cache)
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
#define SPU_OFFSET
static void m32r_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
#define SPI_OFFSET
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition: osabi.c:148
size_t size
Definition: go32-nat.c:242
static const gdb_byte linux_sigtramp_code[]