1 /* Target-dependent code for GNU/Linux on Alpha. 2 Copyright (C) 2002-2017 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #include "defs.h" 20 #include "frame.h" 21 #include "osabi.h" 22 #include "solib-svr4.h" 23 #include "symtab.h" 24 #include "regset.h" 25 #include "regcache.h" 26 #include "linux-tdep.h" 27 #include "alpha-tdep.h" 28 29 /* This enum represents the signals' numbers on the Alpha 30 architecture. It just contains the signal definitions which are 31 different from the generic implementation. 32 33 It is derived from the file <arch/alpha/include/uapi/asm/signal.h>, 34 from the Linux kernel tree. */ 35 36 enum 37 { 38 /* SIGABRT is the same as in the generic implementation, but is 39 defined here because SIGIOT depends on it. */ 40 ALPHA_LINUX_SIGABRT = 6, 41 ALPHA_LINUX_SIGEMT = 7, 42 ALPHA_LINUX_SIGBUS = 10, 43 ALPHA_LINUX_SIGSYS = 12, 44 ALPHA_LINUX_SIGURG = 16, 45 ALPHA_LINUX_SIGSTOP = 17, 46 ALPHA_LINUX_SIGTSTP = 18, 47 ALPHA_LINUX_SIGCONT = 19, 48 ALPHA_LINUX_SIGCHLD = 20, 49 ALPHA_LINUX_SIGIO = 23, 50 ALPHA_LINUX_SIGINFO = 29, 51 ALPHA_LINUX_SIGUSR1 = 30, 52 ALPHA_LINUX_SIGUSR2 = 31, 53 ALPHA_LINUX_SIGPOLL = ALPHA_LINUX_SIGIO, 54 ALPHA_LINUX_SIGPWR = ALPHA_LINUX_SIGINFO, 55 ALPHA_LINUX_SIGIOT = ALPHA_LINUX_SIGABRT, 56 }; 57 58 /* Under GNU/Linux, signal handler invocations can be identified by 59 the designated code sequence that is used to return from a signal 60 handler. In particular, the return address of a signal handler 61 points to a sequence that copies $sp to $16, loads $0 with the 62 appropriate syscall number, and finally enters the kernel. 63 64 This is somewhat complicated in that: 65 (1) the expansion of the "mov" assembler macro has changed over 66 time, from "bis src,src,dst" to "bis zero,src,dst", 67 (2) the kernel has changed from using "addq" to "lda" to load the 68 syscall number, 69 (3) there is a "normal" sigreturn and an "rt" sigreturn which 70 has a different stack layout. */ 71 72 static long 73 alpha_linux_sigtramp_offset_1 (struct gdbarch *gdbarch, CORE_ADDR pc) 74 { 75 switch (alpha_read_insn (gdbarch, pc)) 76 { 77 case 0x47de0410: /* bis $30,$30,$16 */ 78 case 0x47fe0410: /* bis $31,$30,$16 */ 79 return 0; 80 81 case 0x43ecf400: /* addq $31,103,$0 */ 82 case 0x201f0067: /* lda $0,103($31) */ 83 case 0x201f015f: /* lda $0,351($31) */ 84 return 4; 85 86 case 0x00000083: /* call_pal callsys */ 87 return 8; 88 89 default: 90 return -1; 91 } 92 } 93 94 static LONGEST 95 alpha_linux_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc) 96 { 97 long i, off; 98 99 if (pc & 3) 100 return -1; 101 102 /* Guess where we might be in the sequence. */ 103 off = alpha_linux_sigtramp_offset_1 (gdbarch, pc); 104 if (off < 0) 105 return -1; 106 107 /* Verify that the other two insns of the sequence are as we expect. */ 108 pc -= off; 109 for (i = 0; i < 12; i += 4) 110 { 111 if (i == off) 112 continue; 113 if (alpha_linux_sigtramp_offset_1 (gdbarch, pc + i) != i) 114 return -1; 115 } 116 117 return off; 118 } 119 120 static int 121 alpha_linux_pc_in_sigtramp (struct gdbarch *gdbarch, 122 CORE_ADDR pc, const char *func_name) 123 { 124 return alpha_linux_sigtramp_offset (gdbarch, pc) >= 0; 125 } 126 127 static CORE_ADDR 128 alpha_linux_sigcontext_addr (struct frame_info *this_frame) 129 { 130 struct gdbarch *gdbarch = get_frame_arch (this_frame); 131 CORE_ADDR pc; 132 ULONGEST sp; 133 long off; 134 135 pc = get_frame_pc (this_frame); 136 sp = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM); 137 138 off = alpha_linux_sigtramp_offset (gdbarch, pc); 139 gdb_assert (off >= 0); 140 141 /* __NR_rt_sigreturn has a couple of structures on the stack. This is: 142 143 struct rt_sigframe { 144 struct siginfo info; 145 struct ucontext uc; 146 }; 147 148 offsetof (struct rt_sigframe, uc.uc_mcontext); */ 149 150 if (alpha_read_insn (gdbarch, pc - off + 4) == 0x201f015f) 151 return sp + 176; 152 153 /* __NR_sigreturn has the sigcontext structure at the top of the stack. */ 154 return sp; 155 } 156 157 /* Supply register REGNUM from the buffer specified by GREGS and LEN 158 in the general-purpose register set REGSET to register cache 159 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ 160 161 static void 162 alpha_linux_supply_gregset (const struct regset *regset, 163 struct regcache *regcache, 164 int regnum, const void *gregs, size_t len) 165 { 166 const gdb_byte *regs = (const gdb_byte *) gregs; 167 168 gdb_assert (len >= 32 * 8); 169 alpha_supply_int_regs (regcache, regnum, regs, regs + 31 * 8, 170 len >= 33 * 8 ? regs + 32 * 8 : NULL); 171 } 172 173 /* Collect register REGNUM from the register cache REGCACHE and store 174 it in the buffer specified by GREGS and LEN as described by the 175 general-purpose register set REGSET. If REGNUM is -1, do this for 176 all registers in REGSET. */ 177 178 static void 179 alpha_linux_collect_gregset (const struct regset *regset, 180 const struct regcache *regcache, 181 int regnum, void *gregs, size_t len) 182 { 183 gdb_byte *regs = (gdb_byte *) gregs; 184 185 gdb_assert (len >= 32 * 8); 186 alpha_fill_int_regs (regcache, regnum, regs, regs + 31 * 8, 187 len >= 33 * 8 ? regs + 32 * 8 : NULL); 188 } 189 190 /* Supply register REGNUM from the buffer specified by FPREGS and LEN 191 in the floating-point register set REGSET to register cache 192 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ 193 194 static void 195 alpha_linux_supply_fpregset (const struct regset *regset, 196 struct regcache *regcache, 197 int regnum, const void *fpregs, size_t len) 198 { 199 const gdb_byte *regs = (const gdb_byte *) fpregs; 200 201 gdb_assert (len >= 32 * 8); 202 alpha_supply_fp_regs (regcache, regnum, regs, regs + 31 * 8); 203 } 204 205 /* Collect register REGNUM from the register cache REGCACHE and store 206 it in the buffer specified by FPREGS and LEN as described by the 207 general-purpose register set REGSET. If REGNUM is -1, do this for 208 all registers in REGSET. */ 209 210 static void 211 alpha_linux_collect_fpregset (const struct regset *regset, 212 const struct regcache *regcache, 213 int regnum, void *fpregs, size_t len) 214 { 215 gdb_byte *regs = (gdb_byte *) fpregs; 216 217 gdb_assert (len >= 32 * 8); 218 alpha_fill_fp_regs (regcache, regnum, regs, regs + 31 * 8); 219 } 220 221 static const struct regset alpha_linux_gregset = 222 { 223 NULL, 224 alpha_linux_supply_gregset, alpha_linux_collect_gregset 225 }; 226 227 static const struct regset alpha_linux_fpregset = 228 { 229 NULL, 230 alpha_linux_supply_fpregset, alpha_linux_collect_fpregset 231 }; 232 233 /* Iterate over core file register note sections. */ 234 235 static void 236 alpha_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 237 iterate_over_regset_sections_cb *cb, 238 void *cb_data, 239 const struct regcache *regcache) 240 { 241 cb (".reg", 32 * 8, &alpha_linux_gregset, NULL, cb_data); 242 cb (".reg2", 32 * 8, &alpha_linux_fpregset, NULL, cb_data); 243 } 244 245 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in 246 gdbarch.h. */ 247 248 static enum gdb_signal 249 alpha_linux_gdb_signal_from_target (struct gdbarch *gdbarch, 250 int signal) 251 { 252 switch (signal) 253 { 254 case ALPHA_LINUX_SIGEMT: 255 return GDB_SIGNAL_EMT; 256 257 case ALPHA_LINUX_SIGBUS: 258 return GDB_SIGNAL_BUS; 259 260 case ALPHA_LINUX_SIGSYS: 261 return GDB_SIGNAL_SYS; 262 263 case ALPHA_LINUX_SIGURG: 264 return GDB_SIGNAL_URG; 265 266 case ALPHA_LINUX_SIGSTOP: 267 return GDB_SIGNAL_STOP; 268 269 case ALPHA_LINUX_SIGTSTP: 270 return GDB_SIGNAL_TSTP; 271 272 case ALPHA_LINUX_SIGCONT: 273 return GDB_SIGNAL_CONT; 274 275 case ALPHA_LINUX_SIGCHLD: 276 return GDB_SIGNAL_CHLD; 277 278 /* No way to differentiate between SIGIO and SIGPOLL. 279 Therefore, we just handle the first one. */ 280 case ALPHA_LINUX_SIGIO: 281 return GDB_SIGNAL_IO; 282 283 /* No way to differentiate between SIGINFO and SIGPWR. 284 Therefore, we just handle the first one. */ 285 case ALPHA_LINUX_SIGINFO: 286 return GDB_SIGNAL_INFO; 287 288 case ALPHA_LINUX_SIGUSR1: 289 return GDB_SIGNAL_USR1; 290 291 case ALPHA_LINUX_SIGUSR2: 292 return GDB_SIGNAL_USR2; 293 } 294 295 return linux_gdb_signal_from_target (gdbarch, signal); 296 } 297 298 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in 299 gdbarch.h. */ 300 301 static int 302 alpha_linux_gdb_signal_to_target (struct gdbarch *gdbarch, 303 enum gdb_signal signal) 304 { 305 switch (signal) 306 { 307 case GDB_SIGNAL_EMT: 308 return ALPHA_LINUX_SIGEMT; 309 310 case GDB_SIGNAL_BUS: 311 return ALPHA_LINUX_SIGBUS; 312 313 case GDB_SIGNAL_SYS: 314 return ALPHA_LINUX_SIGSYS; 315 316 case GDB_SIGNAL_URG: 317 return ALPHA_LINUX_SIGURG; 318 319 case GDB_SIGNAL_STOP: 320 return ALPHA_LINUX_SIGSTOP; 321 322 case GDB_SIGNAL_TSTP: 323 return ALPHA_LINUX_SIGTSTP; 324 325 case GDB_SIGNAL_CONT: 326 return ALPHA_LINUX_SIGCONT; 327 328 case GDB_SIGNAL_CHLD: 329 return ALPHA_LINUX_SIGCHLD; 330 331 case GDB_SIGNAL_IO: 332 return ALPHA_LINUX_SIGIO; 333 334 case GDB_SIGNAL_INFO: 335 return ALPHA_LINUX_SIGINFO; 336 337 case GDB_SIGNAL_USR1: 338 return ALPHA_LINUX_SIGUSR1; 339 340 case GDB_SIGNAL_USR2: 341 return ALPHA_LINUX_SIGUSR2; 342 343 case GDB_SIGNAL_POLL: 344 return ALPHA_LINUX_SIGPOLL; 345 346 case GDB_SIGNAL_PWR: 347 return ALPHA_LINUX_SIGPWR; 348 } 349 350 return linux_gdb_signal_to_target (gdbarch, signal); 351 } 352 353 static void 354 alpha_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 355 { 356 struct gdbarch_tdep *tdep; 357 358 linux_init_abi (info, gdbarch); 359 360 /* Hook into the DWARF CFI frame unwinder. */ 361 alpha_dwarf2_init_abi (info, gdbarch); 362 363 /* Hook into the MDEBUG frame unwinder. */ 364 alpha_mdebug_init_abi (info, gdbarch); 365 366 tdep = gdbarch_tdep (gdbarch); 367 tdep->dynamic_sigtramp_offset = alpha_linux_sigtramp_offset; 368 tdep->sigcontext_addr = alpha_linux_sigcontext_addr; 369 tdep->pc_in_sigtramp = alpha_linux_pc_in_sigtramp; 370 tdep->jb_pc = 2; 371 tdep->jb_elt_size = 8; 372 373 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 374 375 set_solib_svr4_fetch_link_map_offsets 376 (gdbarch, svr4_lp64_fetch_link_map_offsets); 377 378 /* Enable TLS support. */ 379 set_gdbarch_fetch_tls_load_module_address (gdbarch, 380 svr4_fetch_objfile_link_map); 381 382 set_gdbarch_iterate_over_regset_sections 383 (gdbarch, alpha_linux_iterate_over_regset_sections); 384 385 set_gdbarch_gdb_signal_from_target (gdbarch, 386 alpha_linux_gdb_signal_from_target); 387 set_gdbarch_gdb_signal_to_target (gdbarch, 388 alpha_linux_gdb_signal_to_target); 389 } 390 391 /* Provide a prototype to silence -Wmissing-prototypes. */ 392 extern initialize_file_ftype _initialize_alpha_linux_tdep; 393 394 void 395 _initialize_alpha_linux_tdep (void) 396 { 397 gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX, 398 alpha_linux_init_abi); 399 } 400