1 /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
4 Copyright (C) 2004, 2006-2012 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/>. */
30 #include "trad-frame.h"
31 #include "frame-unwind.h"
33 #include "gdb_string.h"
34 #include "linux-tdep.h"
36 /* Define the size (in bytes) of an FR-V instruction. */
37 static const int frv_instr_size
= 4;
45 frv_linux_pc_in_sigtramp (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
47 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
48 char buf
[frv_instr_size
];
52 if (target_read_memory (pc
, buf
, sizeof buf
) != 0)
55 instr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
57 if (instr
== 0x8efc0077) /* setlos #__NR_sigreturn, gr7 */
58 retval
= NORMAL_SIGTRAMP
;
59 else if (instr
-= 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */
64 if (target_read_memory (pc
+ frv_instr_size
, buf
, sizeof buf
) != 0)
66 instr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
67 if (instr
!= 0xc0700000) /* tira gr0, 0 */
70 /* If we get this far, we'll return a non-zero value, either
71 NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2). */
75 /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
76 wish to decode, and REGNO, one of the frv register numbers defined
77 in frv-tdep.h, return the address of the saved register (corresponding
78 to REGNO) in the sigtramp frame. Return -1 if the register is not
79 found in the sigtramp frame. The magic numbers in the code below
80 were computed by examining the following kernel structs:
82 From arch/frv/kernel/signal.c:
86 void (*pretcode)(void);
89 unsigned long extramask[_NSIG_WORDS-1];
95 void (*pretcode)(void);
97 struct siginfo *pinfo;
104 From include/asm-frv/ucontext.h:
107 unsigned long uc_flags;
108 struct ucontext *uc_link;
110 struct sigcontext uc_mcontext;
114 From include/asm-frv/signal.h:
116 typedef struct sigaltstack {
122 From include/asm-frv/sigcontext.h:
125 struct user_context sc_context;
126 unsigned long sc_oldmask;
127 } __attribute__((aligned(8)));
129 From include/asm-frv/registers.h:
139 unsigned long __status;
140 unsigned long syscallno;
141 unsigned long orig_gr8;
142 unsigned long gner[2];
143 unsigned long long iacc[1];
147 unsigned long gr[64];
151 struct user_fpmedia_regs
153 unsigned long fr[64];
154 unsigned long fner[2];
155 unsigned long msr[2];
156 unsigned long acc[8];
157 unsigned char accg[8];
158 unsigned long fsr[1];
163 struct user_int_regs i;
164 struct user_fpmedia_regs f;
167 } __attribute__((aligned(8))); */
170 frv_linux_sigcontext_reg_addr (struct frame_info
*this_frame
, int regno
,
171 CORE_ADDR
*sc_addr_cache_ptr
)
173 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
174 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
177 if (sc_addr_cache_ptr
&& *sc_addr_cache_ptr
)
179 sc_addr
= *sc_addr_cache_ptr
;
187 pc
= get_frame_pc (this_frame
);
188 tramp_type
= frv_linux_pc_in_sigtramp (gdbarch
, pc
, 0);
190 get_frame_register (this_frame
, sp_regnum
, buf
);
191 sp
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
193 if (tramp_type
== NORMAL_SIGTRAMP
)
195 /* For a normal sigtramp frame, the sigcontext struct starts
199 else if (tramp_type
== RT_SIGTRAMP
)
201 /* For a realtime sigtramp frame, SP + 12 contains a pointer
202 to a ucontext struct. The ucontext struct contains a
203 sigcontext struct starting 24 bytes in. (The offset of
204 uc_mcontext within struct ucontext is derived as follows:
205 stack_t is a 12-byte struct and struct sigcontext is
206 8-byte aligned. This gives an offset of 8 + 12 + 4 (for
208 if (target_read_memory (sp
+ 12, buf
, sizeof buf
) != 0)
210 warning (_("Can't read realtime sigtramp frame."));
213 sc_addr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
217 internal_error (__FILE__
, __LINE__
, _("not a signal trampoline"));
219 if (sc_addr_cache_ptr
)
220 *sc_addr_cache_ptr
= sc_addr
;
227 /* sc_addr + 4 has "isr", the Integer Status Register. */
238 /* sc_addr + 28 is __status, the exception status.
239 sc_addr + 32 is syscallno, the syscall number or -1.
240 sc_addr + 36 is orig_gr8, the original syscall arg #1.
241 sc_addr + 40 is gner[0].
242 sc_addr + 44 is gner[1]. */
248 if (first_gpr_regnum
<= regno
&& regno
<= last_gpr_regnum
)
249 return sc_addr
+ 56 + 4 * (regno
- first_gpr_regnum
);
250 else if (first_fpr_regnum
<= regno
&& regno
<= last_fpr_regnum
)
251 return sc_addr
+ 312 + 4 * (regno
- first_fpr_regnum
);
253 return -1; /* not saved. */
257 /* Signal trampolines. */
259 static struct trad_frame_cache
*
260 frv_linux_sigtramp_frame_cache (struct frame_info
*this_frame
,
263 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
264 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
265 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
266 struct trad_frame_cache
*cache
;
270 CORE_ADDR sc_addr_cache_val
= 0;
271 struct frame_id this_id
;
276 cache
= trad_frame_cache_zalloc (this_frame
);
278 /* FIXME: cagney/2004-05-01: This is is long standing broken code.
279 The frame ID's code address should be the start-address of the
280 signal trampoline and not the current PC within that
282 get_frame_register (this_frame
, sp_regnum
, buf
);
283 addr
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
284 this_id
= frame_id_build (addr
, get_frame_pc (this_frame
));
285 trad_frame_set_id (cache
, this_id
);
287 for (regnum
= 0; regnum
< frv_num_regs
; regnum
++)
289 LONGEST reg_addr
= frv_linux_sigcontext_reg_addr (this_frame
, regnum
,
292 trad_frame_set_reg_addr (cache
, regnum
, reg_addr
);
300 frv_linux_sigtramp_frame_this_id (struct frame_info
*this_frame
,
302 struct frame_id
*this_id
)
304 struct trad_frame_cache
*cache
305 = frv_linux_sigtramp_frame_cache (this_frame
, this_cache
);
306 trad_frame_get_id (cache
, this_id
);
309 static struct value
*
310 frv_linux_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
311 void **this_cache
, int regnum
)
313 /* Make sure we've initialized the cache. */
314 struct trad_frame_cache
*cache
315 = frv_linux_sigtramp_frame_cache (this_frame
, this_cache
);
316 return trad_frame_get_register (cache
, this_frame
, regnum
);
320 frv_linux_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
321 struct frame_info
*this_frame
,
324 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
325 CORE_ADDR pc
= get_frame_pc (this_frame
);
328 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
329 if (frv_linux_pc_in_sigtramp (gdbarch
, pc
, name
))
335 static const struct frame_unwind frv_linux_sigtramp_frame_unwind
=
338 default_frame_unwind_stop_reason
,
339 frv_linux_sigtramp_frame_this_id
,
340 frv_linux_sigtramp_frame_prev_register
,
342 frv_linux_sigtramp_frame_sniffer
345 /* The FRV kernel defines ELF_NGREG as 46. We add 2 in order to include
346 the loadmap addresses in the register set. (See below for more info.) */
347 #define FRV_ELF_NGREG (46 + 2)
348 typedef unsigned char frv_elf_greg_t
[4];
349 typedef struct { frv_elf_greg_t reg
[FRV_ELF_NGREG
]; } frv_elf_gregset_t
;
351 typedef unsigned char frv_elf_fpreg_t
[4];
354 frv_elf_fpreg_t fr
[64];
355 frv_elf_fpreg_t fner
[2];
356 frv_elf_fpreg_t msr
[2];
357 frv_elf_fpreg_t acc
[8];
358 unsigned char accg
[8];
359 frv_elf_fpreg_t fsr
[1];
360 } frv_elf_fpregset_t
;
362 /* Constants for accessing elements of frv_elf_gregset_t. */
367 #define FRV_PT_CCCR 3
371 #define FRV_PT_GNER0 10
372 #define FRV_PT_GNER1 11
373 #define FRV_PT_IACC0H 12
374 #define FRV_PT_IACC0L 13
376 /* Note: Only 32 of the GRs will be found in the corefile. */
377 #define FRV_PT_GR(j) ( 14 + (j)) /* GRj for 0<=j<=63. */
379 #define FRV_PT_TBR FRV_PT_GR(0) /* gr0 is always 0, so TBR is stuffed
382 /* Technically, the loadmap addresses are not part of `pr_reg' as
383 found in the elf_prstatus struct. The fields which communicate the
384 loadmap address appear (by design) immediately after `pr_reg'
385 though, and the BFD function elf32_frv_grok_prstatus() has been
386 implemented to include these fields in the register section that it
387 extracts from the core file. So, for our purposes, they may be
388 viewed as registers. */
390 #define FRV_PT_EXEC_FDPIC_LOADMAP 46
391 #define FRV_PT_INTERP_FDPIC_LOADMAP 47
394 /* Unpack an frv_elf_gregset_t into GDB's register cache. */
397 frv_linux_supply_gregset (const struct regset
*regset
,
398 struct regcache
*regcache
,
399 int regnum
, const void *gregs
, size_t len
)
402 char zerobuf
[MAX_REGISTER_SIZE
];
403 const frv_elf_gregset_t
*gregsetp
= gregs
;
405 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
407 /* gr0 always contains 0. Also, the kernel passes the TBR value in
409 regcache_raw_supply (regcache
, first_gpr_regnum
, zerobuf
);
411 for (regi
= first_gpr_regnum
+ 1; regi
<= last_gpr_regnum
; regi
++)
413 if (regi
>= first_gpr_regnum
+ 32)
414 regcache_raw_supply (regcache
, regi
, zerobuf
);
416 regcache_raw_supply (regcache
, regi
,
417 gregsetp
->reg
[FRV_PT_GR (regi
418 - first_gpr_regnum
)]);
421 regcache_raw_supply (regcache
, pc_regnum
, gregsetp
->reg
[FRV_PT_PC
]);
422 regcache_raw_supply (regcache
, psr_regnum
, gregsetp
->reg
[FRV_PT_PSR
]);
423 regcache_raw_supply (regcache
, ccr_regnum
, gregsetp
->reg
[FRV_PT_CCR
]);
424 regcache_raw_supply (regcache
, cccr_regnum
, gregsetp
->reg
[FRV_PT_CCCR
]);
425 regcache_raw_supply (regcache
, lr_regnum
, gregsetp
->reg
[FRV_PT_LR
]);
426 regcache_raw_supply (regcache
, lcr_regnum
, gregsetp
->reg
[FRV_PT_LCR
]);
427 regcache_raw_supply (regcache
, gner0_regnum
, gregsetp
->reg
[FRV_PT_GNER0
]);
428 regcache_raw_supply (regcache
, gner1_regnum
, gregsetp
->reg
[FRV_PT_GNER1
]);
429 regcache_raw_supply (regcache
, tbr_regnum
, gregsetp
->reg
[FRV_PT_TBR
]);
430 regcache_raw_supply (regcache
, fdpic_loadmap_exec_regnum
,
431 gregsetp
->reg
[FRV_PT_EXEC_FDPIC_LOADMAP
]);
432 regcache_raw_supply (regcache
, fdpic_loadmap_interp_regnum
,
433 gregsetp
->reg
[FRV_PT_INTERP_FDPIC_LOADMAP
]);
436 /* Unpack an frv_elf_fpregset_t into GDB's register cache. */
439 frv_linux_supply_fpregset (const struct regset
*regset
,
440 struct regcache
*regcache
,
441 int regnum
, const void *gregs
, size_t len
)
444 const frv_elf_fpregset_t
*fpregsetp
= gregs
;
446 for (regi
= first_fpr_regnum
; regi
<= last_fpr_regnum
; regi
++)
447 regcache_raw_supply (regcache
, regi
,
448 fpregsetp
->fr
[regi
- first_fpr_regnum
]);
450 regcache_raw_supply (regcache
, fner0_regnum
, fpregsetp
->fner
[0]);
451 regcache_raw_supply (regcache
, fner1_regnum
, fpregsetp
->fner
[1]);
453 regcache_raw_supply (regcache
, msr0_regnum
, fpregsetp
->msr
[0]);
454 regcache_raw_supply (regcache
, msr1_regnum
, fpregsetp
->msr
[1]);
456 for (regi
= acc0_regnum
; regi
<= acc7_regnum
; regi
++)
457 regcache_raw_supply (regcache
, regi
, fpregsetp
->acc
[regi
- acc0_regnum
]);
459 regcache_raw_supply (regcache
, accg0123_regnum
, fpregsetp
->accg
);
460 regcache_raw_supply (regcache
, accg4567_regnum
, fpregsetp
->accg
+ 4);
462 regcache_raw_supply (regcache
, fsr0_regnum
, fpregsetp
->fsr
[0]);
465 /* FRV Linux kernel register sets. */
467 static struct regset frv_linux_gregset
=
470 frv_linux_supply_gregset
473 static struct regset frv_linux_fpregset
=
476 frv_linux_supply_fpregset
479 static const struct regset
*
480 frv_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
481 const char *sect_name
, size_t sect_size
)
483 if (strcmp (sect_name
, ".reg") == 0
484 && sect_size
>= sizeof (frv_elf_gregset_t
))
485 return &frv_linux_gregset
;
487 if (strcmp (sect_name
, ".reg2") == 0
488 && sect_size
>= sizeof (frv_elf_fpregset_t
))
489 return &frv_linux_fpregset
;
496 frv_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
498 linux_init_abi (info
, gdbarch
);
500 /* Set the sigtramp frame sniffer. */
501 frame_unwind_append_unwinder (gdbarch
, &frv_linux_sigtramp_frame_unwind
);
503 set_gdbarch_regset_from_core_section (gdbarch
,
504 frv_linux_regset_from_core_section
);
507 static enum gdb_osabi
508 frv_linux_elf_osabi_sniffer (bfd
*abfd
)
512 elf_flags
= elf_elfheader (abfd
)->e_flags
;
514 /* Assume GNU/Linux if using the FDPIC ABI. If/when another OS shows
515 up that uses this ABI, we'll need to start using .note sections
517 if (elf_flags
& EF_FRV_FDPIC
)
518 return GDB_OSABI_LINUX
;
520 return GDB_OSABI_UNKNOWN
;
523 /* Provide a prototype to silence -Wmissing-prototypes. */
524 void _initialize_frv_linux_tdep (void);
527 _initialize_frv_linux_tdep (void)
529 gdbarch_register_osabi (bfd_arch_frv
, 0, GDB_OSABI_LINUX
,
531 gdbarch_register_osabi_sniffer (bfd_arch_frv
,
532 bfd_target_elf_flavour
,
533 frv_linux_elf_osabi_sniffer
);