| 1 | /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V, |
| 2 | for GDB. |
| 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 "target.h" |
| 24 | #include "frame.h" |
| 25 | #include "osabi.h" |
| 26 | #include "elf-bfd.h" |
| 27 | #include "elf/frv.h" |
| 28 | #include "frv-tdep.h" |
| 29 | #include "trad-frame.h" |
| 30 | #include "frame-unwind.h" |
| 31 | |
| 32 | /* Define the size (in bytes) of an FR-V instruction. */ |
| 33 | static const int frv_instr_size = 4; |
| 34 | |
| 35 | enum { |
| 36 | NORMAL_SIGTRAMP = 1, |
| 37 | RT_SIGTRAMP = 2 |
| 38 | }; |
| 39 | |
| 40 | static int |
| 41 | frv_linux_pc_in_sigtramp (CORE_ADDR pc, char *name) |
| 42 | { |
| 43 | char buf[frv_instr_size]; |
| 44 | LONGEST instr; |
| 45 | int retval = 0; |
| 46 | |
| 47 | if (target_read_memory (pc, buf, sizeof buf) != 0) |
| 48 | return 0; |
| 49 | |
| 50 | instr = extract_unsigned_integer (buf, sizeof buf); |
| 51 | |
| 52 | if (instr == 0x8efc0077) /* setlos #__NR_sigreturn, gr7 */ |
| 53 | retval = NORMAL_SIGTRAMP; |
| 54 | else if (instr -= 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */ |
| 55 | retval = RT_SIGTRAMP; |
| 56 | else |
| 57 | return 0; |
| 58 | |
| 59 | if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0) |
| 60 | return 0; |
| 61 | instr = extract_unsigned_integer (buf, sizeof buf); |
| 62 | if (instr != 0xc0700000) /* tira gr0, 0 */ |
| 63 | return 0; |
| 64 | |
| 65 | /* If we get this far, we'll return a non-zero value, either |
| 66 | NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2). */ |
| 67 | return retval; |
| 68 | } |
| 69 | |
| 70 | /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we |
| 71 | wish to decode, and REGNO, one of the frv register numbers defined |
| 72 | in frv-tdep.h, return the address of the saved register (corresponding |
| 73 | to REGNO) in the sigtramp frame. Return -1 if the register is not |
| 74 | found in the sigtramp frame. The magic numbers in the code below |
| 75 | were computed by examining the following kernel structs: |
| 76 | |
| 77 | From arch/frv/kernel/signal.c: |
| 78 | |
| 79 | struct sigframe |
| 80 | { |
| 81 | void (*pretcode)(void); |
| 82 | int sig; |
| 83 | struct sigcontext sc; |
| 84 | unsigned long extramask[_NSIG_WORDS-1]; |
| 85 | uint32_t retcode[2]; |
| 86 | }; |
| 87 | |
| 88 | struct rt_sigframe |
| 89 | { |
| 90 | void (*pretcode)(void); |
| 91 | int sig; |
| 92 | struct siginfo *pinfo; |
| 93 | void *puc; |
| 94 | struct siginfo info; |
| 95 | struct ucontext uc; |
| 96 | uint32_t retcode[2]; |
| 97 | }; |
| 98 | |
| 99 | From include/asm-frv/ucontext.h: |
| 100 | |
| 101 | struct ucontext { |
| 102 | unsigned long uc_flags; |
| 103 | struct ucontext *uc_link; |
| 104 | stack_t uc_stack; |
| 105 | struct sigcontext uc_mcontext; |
| 106 | sigset_t uc_sigmask; |
| 107 | }; |
| 108 | |
| 109 | From include/asm-frv/signal.h: |
| 110 | |
| 111 | typedef struct sigaltstack { |
| 112 | void *ss_sp; |
| 113 | int ss_flags; |
| 114 | size_t ss_size; |
| 115 | } stack_t; |
| 116 | |
| 117 | From include/asm-frv/sigcontext.h: |
| 118 | |
| 119 | struct sigcontext { |
| 120 | struct user_context sc_context; |
| 121 | unsigned long sc_oldmask; |
| 122 | } __attribute__((aligned(8))); |
| 123 | |
| 124 | From include/asm-frv/registers.h: |
| 125 | struct user_int_regs |
| 126 | { |
| 127 | unsigned long psr; |
| 128 | unsigned long isr; |
| 129 | unsigned long ccr; |
| 130 | unsigned long cccr; |
| 131 | unsigned long lr; |
| 132 | unsigned long lcr; |
| 133 | unsigned long pc; |
| 134 | unsigned long __status; |
| 135 | unsigned long syscallno; |
| 136 | unsigned long orig_gr8; |
| 137 | unsigned long gner[2]; |
| 138 | unsigned long long iacc[1]; |
| 139 | |
| 140 | union { |
| 141 | unsigned long tbr; |
| 142 | unsigned long gr[64]; |
| 143 | }; |
| 144 | }; |
| 145 | |
| 146 | struct user_fpmedia_regs |
| 147 | { |
| 148 | unsigned long fr[64]; |
| 149 | unsigned long fner[2]; |
| 150 | unsigned long msr[2]; |
| 151 | unsigned long acc[8]; |
| 152 | unsigned char accg[8]; |
| 153 | unsigned long fsr[1]; |
| 154 | }; |
| 155 | |
| 156 | struct user_context |
| 157 | { |
| 158 | struct user_int_regs i; |
| 159 | struct user_fpmedia_regs f; |
| 160 | |
| 161 | void *extension; |
| 162 | } __attribute__((aligned(8))); */ |
| 163 | |
| 164 | static LONGEST |
| 165 | frv_linux_sigcontext_reg_addr (struct frame_info *next_frame, int regno, |
| 166 | CORE_ADDR *sc_addr_cache_ptr) |
| 167 | { |
| 168 | CORE_ADDR sc_addr; |
| 169 | |
| 170 | if (sc_addr_cache_ptr && *sc_addr_cache_ptr) |
| 171 | { |
| 172 | sc_addr = *sc_addr_cache_ptr; |
| 173 | } |
| 174 | else |
| 175 | { |
| 176 | CORE_ADDR pc, sp; |
| 177 | char buf[4]; |
| 178 | int tramp_type; |
| 179 | |
| 180 | pc = frame_pc_unwind (next_frame); |
| 181 | tramp_type = frv_linux_pc_in_sigtramp (pc, 0); |
| 182 | |
| 183 | frame_unwind_register (next_frame, sp_regnum, buf); |
| 184 | sp = extract_unsigned_integer (buf, sizeof buf); |
| 185 | |
| 186 | if (tramp_type == NORMAL_SIGTRAMP) |
| 187 | { |
| 188 | /* For a normal sigtramp frame, the sigcontext struct starts |
| 189 | at SP + 8. */ |
| 190 | sc_addr = sp + 8; |
| 191 | } |
| 192 | else if (tramp_type == RT_SIGTRAMP) |
| 193 | { |
| 194 | /* For a realtime sigtramp frame, SP + 12 contains a pointer |
| 195 | to a ucontext struct. The ucontext struct contains a |
| 196 | sigcontext struct starting 24 bytes in. (The offset of |
| 197 | uc_mcontext within struct ucontext is derived as follows: |
| 198 | stack_t is a 12-byte struct and struct sigcontext is |
| 199 | 8-byte aligned. This gives an offset of 8 + 12 + 4 (for |
| 200 | padding) = 24.) */ |
| 201 | if (target_read_memory (sp + 12, buf, sizeof buf) != 0) |
| 202 | { |
| 203 | warning (_("Can't read realtime sigtramp frame.")); |
| 204 | return 0; |
| 205 | } |
| 206 | sc_addr = extract_unsigned_integer (buf, sizeof buf); |
| 207 | sc_addr += 24; |
| 208 | } |
| 209 | else |
| 210 | internal_error (__FILE__, __LINE__, _("not a signal trampoline")); |
| 211 | |
| 212 | if (sc_addr_cache_ptr) |
| 213 | *sc_addr_cache_ptr = sc_addr; |
| 214 | } |
| 215 | |
| 216 | switch (regno) |
| 217 | { |
| 218 | case psr_regnum : |
| 219 | return sc_addr + 0; |
| 220 | /* sc_addr + 4 has "isr", the Integer Status Register. */ |
| 221 | case ccr_regnum : |
| 222 | return sc_addr + 8; |
| 223 | case cccr_regnum : |
| 224 | return sc_addr + 12; |
| 225 | case lr_regnum : |
| 226 | return sc_addr + 16; |
| 227 | case lcr_regnum : |
| 228 | return sc_addr + 20; |
| 229 | case pc_regnum : |
| 230 | return sc_addr + 24; |
| 231 | /* sc_addr + 28 is __status, the exception status. |
| 232 | sc_addr + 32 is syscallno, the syscall number or -1. |
| 233 | sc_addr + 36 is orig_gr8, the original syscall arg #1. |
| 234 | sc_addr + 40 is gner[0]. |
| 235 | sc_addr + 44 is gner[1]. */ |
| 236 | case iacc0h_regnum : |
| 237 | return sc_addr + 48; |
| 238 | case iacc0l_regnum : |
| 239 | return sc_addr + 52; |
| 240 | default : |
| 241 | if (first_gpr_regnum <= regno && regno <= last_gpr_regnum) |
| 242 | return sc_addr + 56 + 4 * (regno - first_gpr_regnum); |
| 243 | else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum) |
| 244 | return sc_addr + 312 + 4 * (regno - first_fpr_regnum); |
| 245 | else |
| 246 | return -1; /* not saved. */ |
| 247 | } |
| 248 | } |
| 249 | |
| 250 | /* Signal trampolines. */ |
| 251 | |
| 252 | static struct trad_frame_cache * |
| 253 | frv_linux_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache) |
| 254 | { |
| 255 | struct trad_frame_cache *cache; |
| 256 | struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); |
| 257 | CORE_ADDR addr; |
| 258 | char buf[4]; |
| 259 | int regnum; |
| 260 | CORE_ADDR sc_addr_cache_val = 0; |
| 261 | struct frame_id this_id; |
| 262 | |
| 263 | if (*this_cache) |
| 264 | return *this_cache; |
| 265 | |
| 266 | cache = trad_frame_cache_zalloc (next_frame); |
| 267 | |
| 268 | /* FIXME: cagney/2004-05-01: This is is long standing broken code. |
| 269 | The frame ID's code address should be the start-address of the |
| 270 | signal trampoline and not the current PC within that |
| 271 | trampoline. */ |
| 272 | frame_unwind_register (next_frame, sp_regnum, buf); |
| 273 | this_id = frame_id_build (extract_unsigned_integer (buf, sizeof buf), |
| 274 | frame_pc_unwind (next_frame)); |
| 275 | trad_frame_set_id (cache, this_id); |
| 276 | |
| 277 | for (regnum = 0; regnum < frv_num_regs; regnum++) |
| 278 | { |
| 279 | LONGEST reg_addr = frv_linux_sigcontext_reg_addr (next_frame, regnum, |
| 280 | &sc_addr_cache_val); |
| 281 | if (reg_addr != -1) |
| 282 | trad_frame_set_reg_addr (cache, regnum, reg_addr); |
| 283 | } |
| 284 | |
| 285 | *this_cache = cache; |
| 286 | return cache; |
| 287 | } |
| 288 | |
| 289 | static void |
| 290 | frv_linux_sigtramp_frame_this_id (struct frame_info *next_frame, void **this_cache, |
| 291 | struct frame_id *this_id) |
| 292 | { |
| 293 | struct trad_frame_cache *cache = |
| 294 | frv_linux_sigtramp_frame_cache (next_frame, this_cache); |
| 295 | trad_frame_get_id (cache, this_id); |
| 296 | } |
| 297 | |
| 298 | static void |
| 299 | frv_linux_sigtramp_frame_prev_register (struct frame_info *next_frame, |
| 300 | void **this_cache, |
| 301 | int regnum, int *optimizedp, |
| 302 | enum lval_type *lvalp, CORE_ADDR *addrp, |
| 303 | int *realnump, void *valuep) |
| 304 | { |
| 305 | /* Make sure we've initialized the cache. */ |
| 306 | struct trad_frame_cache *cache = |
| 307 | frv_linux_sigtramp_frame_cache (next_frame, this_cache); |
| 308 | trad_frame_get_register (cache, next_frame, regnum, optimizedp, lvalp, |
| 309 | addrp, realnump, valuep); |
| 310 | } |
| 311 | |
| 312 | static const struct frame_unwind frv_linux_sigtramp_frame_unwind = |
| 313 | { |
| 314 | SIGTRAMP_FRAME, |
| 315 | frv_linux_sigtramp_frame_this_id, |
| 316 | frv_linux_sigtramp_frame_prev_register |
| 317 | }; |
| 318 | |
| 319 | static const struct frame_unwind * |
| 320 | frv_linux_sigtramp_frame_sniffer (struct frame_info *next_frame) |
| 321 | { |
| 322 | CORE_ADDR pc = frame_pc_unwind (next_frame); |
| 323 | char *name; |
| 324 | |
| 325 | find_pc_partial_function (pc, &name, NULL, NULL); |
| 326 | if (frv_linux_pc_in_sigtramp (pc, name)) |
| 327 | return &frv_linux_sigtramp_frame_unwind; |
| 328 | |
| 329 | return NULL; |
| 330 | } |
| 331 | |
| 332 | static void |
| 333 | frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) |
| 334 | { |
| 335 | /* Set the sigtramp frame sniffer. */ |
| 336 | frame_unwind_append_sniffer (gdbarch, frv_linux_sigtramp_frame_sniffer); |
| 337 | } |
| 338 | |
| 339 | static enum gdb_osabi |
| 340 | frv_linux_elf_osabi_sniffer (bfd *abfd) |
| 341 | { |
| 342 | int elf_flags; |
| 343 | |
| 344 | elf_flags = elf_elfheader (abfd)->e_flags; |
| 345 | |
| 346 | /* Assume GNU/Linux if using the FDPIC ABI. If/when another OS shows |
| 347 | up that uses this ABI, we'll need to start using .note sections |
| 348 | or some such. */ |
| 349 | if (elf_flags & EF_FRV_FDPIC) |
| 350 | return GDB_OSABI_LINUX; |
| 351 | else |
| 352 | return GDB_OSABI_UNKNOWN; |
| 353 | } |
| 354 | |
| 355 | /* Provide a prototype to silence -Wmissing-prototypes. */ |
| 356 | void _initialize_frv_linux_tdep (void); |
| 357 | |
| 358 | void |
| 359 | _initialize_frv_linux_tdep (void) |
| 360 | { |
| 361 | gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX, frv_linux_init_abi); |
| 362 | gdbarch_register_osabi_sniffer (bfd_arch_frv, |
| 363 | bfd_target_elf_flavour, |
| 364 | frv_linux_elf_osabi_sniffer); |
| 365 | } |