GDB (xrefs)
Loading...
Searching...
No Matches
m32r-linux-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for GNU/Linux m32r.
2
3 Copyright (C) 2004-2023 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#include "gdbarch.h"
40
41
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
80static const gdb_byte 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
87static CORE_ADDR
88m32r_linux_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame)
89{
90 gdb_byte 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 (this_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 (this_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
128static const gdb_byte 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
135static CORE_ADDR
137{
138 gdb_byte 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 (this_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 (this_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 (this_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
174static int
175m32r_linux_pc_in_sigtramp (CORE_ADDR pc, const char *name,
176 frame_info_ptr this_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, this_frame) != 0
185 || m32r_linux_rt_sigtramp_start (pc, this_frame) != 0);
186
187 return (strcmp ("__restore", name) == 0
188 || strcmp ("__restore_rt", name) == 0);
189}
190
191/* From <asm/sigcontext.h>. */
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
224
225static struct m32r_frame_cache *
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 (struct m32r_frame_cache *) (*this_cache);
235 cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
236 (*this_cache) = cache;
237 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
238
239 cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM);
240 sigcontext_addr = cache->base + 4;
241
242 cache->pc = get_frame_pc (this_frame);
243 addr = m32r_linux_sigtramp_start (cache->pc, this_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, this_frame);
249 if (addr)
250 sigcontext_addr += 128;
251 else
252 addr = get_frame_func (this_frame);
253 }
254 cache->pc = addr;
255
256 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
257
258 for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++)
259 {
261 cache->saved_regs[regnum].set_addr (sigcontext_addr
263 }
264
265 return cache;
266}
267
268static void
270 void **this_cache,
271 struct frame_id *this_id)
272{
273 struct m32r_frame_cache *cache =
274 m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
275
276 (*this_id) = frame_id_build (cache->base, cache->pc);
277}
278
279static struct value *
281 void **this_cache, int regnum)
282{
283 struct m32r_frame_cache *cache =
284 m32r_linux_sigtramp_frame_cache (this_frame, this_cache);
285
286 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
287}
288
289static int
291 frame_info_ptr this_frame,
292 void **this_cache)
293{
294 CORE_ADDR pc = get_frame_pc (this_frame);
295 const char *name;
296
297 find_pc_partial_function (pc, &name, NULL, NULL);
298 if (m32r_linux_pc_in_sigtramp (pc, name, this_frame))
299 return 1;
300
301 return 0;
302}
303
313
314/* Mapping between the registers in `struct pt_regs'
315 format and GDB's register array layout. */
316
317static int m32r_pt_regs_offset[] = {
318 4 * 4, /* r0 */
319 4 * 5, /* r1 */
320 4 * 6, /* r2 */
321 4 * 7, /* r3 */
322 4 * 0, /* r4 */
323 4 * 1, /* r5 */
324 4 * 2, /* r6 */
325 4 * 8, /* r7 */
326 4 * 9, /* r8 */
327 4 * 10, /* r9 */
328 4 * 11, /* r10 */
329 4 * 12, /* r11 */
330 4 * 13, /* r12 */
331 4 * 24, /* fp */
332 4 * 25, /* lr */
333 4 * 23, /* sp */
334 4 * 19, /* psw */
335 4 * 19, /* cbr */
336 4 * 26, /* spi */
337 4 * 23, /* spu */
338 4 * 22, /* bpc */
339 4 * 20, /* pc */
340 4 * 16, /* accl */
341 4 * 15 /* acch */
342};
343
344#define PSW_OFFSET (4 * 19)
345#define BBPSW_OFFSET (4 * 21)
346#define SPU_OFFSET (4 * 23)
347#define SPI_OFFSET (4 * 26)
348
349#define M32R_LINUX_GREGS_SIZE (4 * 28)
350
351static void
353 struct regcache *regcache, int regnum,
354 const void *gregs, size_t size)
355{
356 const gdb_byte *regs = (const gdb_byte *) gregs;
357 enum bfd_endian byte_order =
359 ULONGEST psw, bbpsw;
360 gdb_byte buf[4];
361 const gdb_byte *p;
362 int i;
363
364 psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order);
365 bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order);
366 psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
367
368 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
369 {
370 if (regnum != -1 && regnum != i)
371 continue;
372
373 switch (i)
374 {
375 case PSW_REGNUM:
376 store_unsigned_integer (buf, 4, byte_order, psw);
377 p = buf;
378 break;
379 case CBR_REGNUM:
380 store_unsigned_integer (buf, 4, byte_order, psw & 1);
381 p = buf;
382 break;
383 case M32R_SP_REGNUM:
384 p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET);
385 break;
386 default:
387 p = regs + m32r_pt_regs_offset[i];
388 }
389
390 regcache->raw_supply (i, p);
391 }
392}
393
394static void
396 const struct regcache *regcache,
397 int regnum, void *gregs, size_t size)
398{
399 gdb_byte *regs = (gdb_byte *) gregs;
400 int i;
401 enum bfd_endian byte_order =
403 ULONGEST psw;
404 gdb_byte buf[4];
405
407 psw = extract_unsigned_integer (buf, 4, byte_order);
408
409 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++)
410 {
411 if (regnum != -1 && regnum != i)
412 continue;
413
414 switch (i)
415 {
416 case PSW_REGNUM:
417 store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order,
418 (psw & 0xc1) << 8);
419 store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order,
420 (psw >> 8) & 0xc1);
421 break;
422 case CBR_REGNUM:
423 break;
424 case M32R_SP_REGNUM:
426 (i, regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET));
427 break;
428 default:
430 }
431 }
432}
433
438
439static void
442 void *cb_data,
443 const struct regcache *regcache)
444{
446 NULL, cb_data);
447}
448
449static void
451{
452
453 linux_init_abi (info, gdbarch, 0);
454
455 /* Since EVB register is not available for native debug, we reduce
456 the number of registers. */
458
460
461 /* GNU/Linux uses SVR4-style shared libraries. */
465
466 /* Core file support. */
469
470 /* Enable TLS support. */
473}
474
476void
int regnum
const char *const name
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
gdbarch * arch() const
Definition regcache.c:231
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1127
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
bool safe_frame_unwind_memory(frame_info_ptr this_frame, CORE_ADDR addr, gdb::array_view< gdb_byte > buffer)
Definition frame.c:3017
@ SIGTRAMP_FRAME
Definition frame.h:198
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
size_t size
Definition go32-nat.c:239
link_map_offsets * linux_ilp32_fetch_link_map_offsets()
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
static CORE_ADDR m32r_linux_sigtramp_start(CORE_ADDR pc, frame_info_ptr this_frame)
static struct m32r_frame_cache * m32r_linux_sigtramp_frame_cache(frame_info_ptr this_frame, void **this_cache)
static void m32r_linux_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t size)
#define SPU_OFFSET
static int m32r_linux_pc_in_sigtramp(CORE_ADDR pc, const char *name, frame_info_ptr this_frame)
void _initialize_m32r_linux_tdep()
#define SPI_OFFSET
static const gdb_byte linux_sigtramp_code[]
static void m32r_linux_sigtramp_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static const gdb_byte linux_rt_sigtramp_code[]
static struct value * m32r_linux_sigtramp_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static const struct regset m32r_linux_gregset
static const struct frame_unwind m32r_linux_sigtramp_frame_unwind
#define BBPSW_OFFSET
static void m32r_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
#define PSW_OFFSET
static int m32r_linux_sc_reg_offset[]
static CORE_ADDR m32r_linux_rt_sigtramp_start(CORE_ADDR pc, frame_info_ptr this_frame)
static int m32r_pt_regs_offset[]
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_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
#define M32R_LINUX_GREGS_SIZE
static int m32r_linux_sigtramp_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
@ M32R_SP_REGNUM
Definition m32r-tdep.h:38
@ CBR_REGNUM
Definition m32r-tdep.h:40
@ PSW_REGNUM
Definition m32r-tdep.h:39
#define M32R_NUM_REGS
Definition m32r-tdep.h:50
CORE_ADDR find_solib_trampoline_target(frame_info_ptr frame, CORE_ADDR pc)
Definition minsyms.c:1554
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:146
@ GDB_OSABI_LINUX
Definition osabi.h:32
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
trad_frame_saved_reg * saved_regs
void set_addr(LONGEST addr)
Definition trad-frame.h:102
Definition value.h:130
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187