1 /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
4 Copyright (C) 2004-2019 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Local non-gdb includes. */
26 #include "frame-unwind.h"
30 #include "linux-tdep.h"
35 #include "trad-frame.h"
37 /* Define the size (in bytes) of an FR-V instruction. */
38 static const int frv_instr_size = 4;
46 frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
49 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
50 gdb_byte buf[frv_instr_size];
54 if (target_read_memory (pc, buf, sizeof buf) != 0)
57 instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
59 if (instr == 0x8efc0077) /* setlos #__NR_sigreturn, gr7 */
60 retval = NORMAL_SIGTRAMP;
61 else if (instr == 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */
66 if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
68 instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
69 if (instr != 0xc0700000) /* tira gr0, 0 */
72 /* If we get this far, we'll return a non-zero value, either
73 NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2). */
77 /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
78 wish to decode, and REGNO, one of the frv register numbers defined
79 in frv-tdep.h, return the address of the saved register (corresponding
80 to REGNO) in the sigtramp frame. Return -1 if the register is not
81 found in the sigtramp frame. The magic numbers in the code below
82 were computed by examining the following kernel structs:
84 From arch/frv/kernel/signal.c:
88 void (*pretcode)(void);
91 unsigned long extramask[_NSIG_WORDS-1];
97 void (*pretcode)(void);
99 struct siginfo *pinfo;
106 From include/asm-frv/ucontext.h:
109 unsigned long uc_flags;
110 struct ucontext *uc_link;
112 struct sigcontext uc_mcontext;
116 From include/asm-frv/signal.h:
118 typedef struct sigaltstack {
124 From include/asm-frv/sigcontext.h:
127 struct user_context sc_context;
128 unsigned long sc_oldmask;
129 } __attribute__((aligned(8)));
131 From include/asm-frv/registers.h:
141 unsigned long __status;
142 unsigned long syscallno;
143 unsigned long orig_gr8;
144 unsigned long gner[2];
145 unsigned long long iacc[1];
149 unsigned long gr[64];
153 struct user_fpmedia_regs
155 unsigned long fr[64];
156 unsigned long fner[2];
157 unsigned long msr[2];
158 unsigned long acc[8];
159 unsigned char accg[8];
160 unsigned long fsr[1];
165 struct user_int_regs i;
166 struct user_fpmedia_regs f;
169 } __attribute__((aligned(8))); */
172 frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
173 CORE_ADDR *sc_addr_cache_ptr)
175 struct gdbarch *gdbarch = get_frame_arch (this_frame);
176 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
179 if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
181 sc_addr = *sc_addr_cache_ptr;
189 pc = get_frame_pc (this_frame);
190 tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);
192 get_frame_register (this_frame, sp_regnum, buf);
193 sp = extract_unsigned_integer (buf, sizeof buf, byte_order);
195 if (tramp_type == NORMAL_SIGTRAMP)
197 /* For a normal sigtramp frame, the sigcontext struct starts
201 else if (tramp_type == RT_SIGTRAMP)
203 /* For a realtime sigtramp frame, SP + 12 contains a pointer
204 to a ucontext struct. The ucontext struct contains a
205 sigcontext struct starting 24 bytes in. (The offset of
206 uc_mcontext within struct ucontext is derived as follows:
207 stack_t is a 12-byte struct and struct sigcontext is
208 8-byte aligned. This gives an offset of 8 + 12 + 4 (for
210 if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
212 warning (_("Can't read realtime sigtramp frame."));
215 sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
219 internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
221 if (sc_addr_cache_ptr)
222 *sc_addr_cache_ptr = sc_addr;
229 /* sc_addr + 4 has "isr", the Integer Status Register. */
240 /* sc_addr + 28 is __status, the exception status.
241 sc_addr + 32 is syscallno, the syscall number or -1.
242 sc_addr + 36 is orig_gr8, the original syscall arg #1.
243 sc_addr + 40 is gner[0].
244 sc_addr + 44 is gner[1]. */
250 if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
251 return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
252 else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
253 return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
255 return -1; /* not saved. */
259 /* Signal trampolines. */
261 static struct trad_frame_cache *
262 frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
265 struct gdbarch *gdbarch = get_frame_arch (this_frame);
266 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
267 struct trad_frame_cache *cache;
271 CORE_ADDR sc_addr_cache_val = 0;
272 struct frame_id this_id;
275 return (struct trad_frame_cache *) *this_cache;
277 cache = trad_frame_cache_zalloc (this_frame);
279 /* FIXME: cagney/2004-05-01: This is is long standing broken code.
280 The frame ID's code address should be the start-address of the
281 signal trampoline and not the current PC within that
283 get_frame_register (this_frame, sp_regnum, buf);
284 addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
285 this_id = frame_id_build (addr, get_frame_pc (this_frame));
286 trad_frame_set_id (cache, this_id);
288 for (regnum = 0; regnum < frv_num_regs; regnum++)
290 LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
293 trad_frame_set_reg_addr (cache, regnum, reg_addr);
301 frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
303 struct frame_id *this_id)
305 struct trad_frame_cache *cache
306 = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
307 trad_frame_get_id (cache, this_id);
310 static struct value *
311 frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
312 void **this_cache, int regnum)
314 /* Make sure we've initialized the cache. */
315 struct trad_frame_cache *cache
316 = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
317 return trad_frame_get_register (cache, this_frame, regnum);
321 frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
322 struct frame_info *this_frame,
325 struct gdbarch *gdbarch = get_frame_arch (this_frame);
326 CORE_ADDR pc = get_frame_pc (this_frame);
329 find_pc_partial_function (pc, &name, NULL, NULL);
330 if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
336 static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
339 default_frame_unwind_stop_reason,
340 frv_linux_sigtramp_frame_this_id,
341 frv_linux_sigtramp_frame_prev_register,
343 frv_linux_sigtramp_frame_sniffer
346 /* The FRV kernel defines ELF_NGREG as 46. We add 2 in order to include
347 the loadmap addresses in the register set. (See below for more info.) */
348 #define FRV_ELF_NGREG (46 + 2)
349 typedef unsigned char frv_elf_greg_t[4];
350 typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;
352 typedef unsigned char frv_elf_fpreg_t[4];
355 frv_elf_fpreg_t fr[64];
356 frv_elf_fpreg_t fner[2];
357 frv_elf_fpreg_t msr[2];
358 frv_elf_fpreg_t acc[8];
359 unsigned char accg[8];
360 frv_elf_fpreg_t fsr[1];
361 } frv_elf_fpregset_t;
365 static const struct regcache_map_entry frv_linux_gregmap[] =
367 { 1, psr_regnum, 4 },
368 { 1, REGCACHE_MAP_SKIP, 4 }, /* isr */
369 { 1, ccr_regnum, 4 },
370 { 1, cccr_regnum, 4 },
372 { 1, lcr_regnum, 4 },
374 { 1, REGCACHE_MAP_SKIP, 4 }, /* __status */
375 { 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */
376 { 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */
377 { 1, gner0_regnum, 4 },
378 { 1, gner1_regnum, 4 },
379 { 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */
380 { 1, tbr_regnum, 4 },
381 { 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */
383 /* Technically, the loadmap addresses are not part of `pr_reg' as
384 found in the elf_prstatus struct. The fields which communicate
385 the loadmap address appear (by design) immediately after
386 `pr_reg' though, and the BFD function elf32_frv_grok_prstatus()
387 has been implemented to include these fields in the register
388 section that it extracts from the core file. So, for our
389 purposes, they may be viewed as registers. */
391 { 1, fdpic_loadmap_exec_regnum, 4 },
392 { 1, fdpic_loadmap_interp_regnum, 4 },
396 static const struct regcache_map_entry frv_linux_fpregmap[] =
398 { 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */
399 { 1, fner0_regnum, 4 },
400 { 1, fner1_regnum, 4 },
401 { 1, msr0_regnum, 4 },
402 { 1, msr1_regnum, 4 },
403 { 8, acc0_regnum, 4 }, /* acc0 ... acc7 */
404 { 1, accg0123_regnum, 4 },
405 { 1, accg4567_regnum, 4 },
406 { 1, fsr0_regnum, 4 },
410 /* Unpack an frv_elf_gregset_t into GDB's register cache. */
413 frv_linux_supply_gregset (const struct regset *regset,
414 struct regcache *regcache,
415 int regnum, const void *gregs, size_t len)
419 /* gr0 always contains 0. Also, the kernel passes the TBR value in
421 regcache->raw_supply_zeroed (first_gpr_regnum);
423 /* Fill gr32, ..., gr63 with zeros. */
424 for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++)
425 regcache->raw_supply_zeroed (regi);
427 regcache_supply_regset (regset, regcache, regnum, gregs, len);
430 /* FRV Linux kernel register sets. */
432 static const struct regset frv_linux_gregset =
435 frv_linux_supply_gregset, regcache_collect_regset
438 static const struct regset frv_linux_fpregset =
441 regcache_supply_regset, regcache_collect_regset
445 frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
446 iterate_over_regset_sections_cb *cb,
448 const struct regcache *regcache)
450 cb (".reg", sizeof (frv_elf_gregset_t), sizeof (frv_elf_gregset_t),
451 &frv_linux_gregset, NULL, cb_data);
452 cb (".reg2", sizeof (frv_elf_fpregset_t), sizeof (frv_elf_fpregset_t),
453 &frv_linux_fpregset, NULL, cb_data);
458 frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
460 linux_init_abi (info, gdbarch);
462 /* Set the sigtramp frame sniffer. */
463 frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind);
465 set_gdbarch_iterate_over_regset_sections
466 (gdbarch, frv_linux_iterate_over_regset_sections);
469 static enum gdb_osabi
470 frv_linux_elf_osabi_sniffer (bfd *abfd)
474 elf_flags = elf_elfheader (abfd)->e_flags;
476 /* Assume GNU/Linux if using the FDPIC ABI. If/when another OS shows
477 up that uses this ABI, we'll need to start using .note sections
479 if (elf_flags & EF_FRV_FDPIC)
480 return GDB_OSABI_LINUX;
482 return GDB_OSABI_UNKNOWN;
486 _initialize_frv_linux_tdep (void)
488 gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
490 gdbarch_register_osabi_sniffer (bfd_arch_frv,
491 bfd_target_elf_flavour,
492 frv_linux_elf_osabi_sniffer);