1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. 2 3 Copyright (C) 2004-2015 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 "osabi.h" 23 #include "target.h" 24 #include "objfiles.h" 25 #include "solib-svr4.h" 26 #include "glibc-tdep.h" 27 #include "frame-unwind.h" 28 #include "trad-frame.h" 29 #include "dwarf2-frame.h" 30 #include "value.h" 31 #include "regset.h" 32 #include "regcache.h" 33 #include "hppa-tdep.h" 34 #include "linux-tdep.h" 35 #include "elf/common.h" 36 37 /* Map DWARF DBX register numbers to GDB register numbers. */ 38 static int 39 hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) 40 { 41 /* The general registers and the sar are the same in both sets. */ 42 if (reg <= 32) 43 return reg; 44 45 /* fr4-fr31 (left and right halves) are mapped from 72. */ 46 if (reg >= 72 && reg <= 72 + 28 * 2) 47 return HPPA_FP4_REGNUM + (reg - 72); 48 49 warning (_("Unmapped DWARF DBX Register #%d encountered."), reg); 50 return -1; 51 } 52 53 static void 54 hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v) 55 { 56 /* Probably this should be done by the kernel, but it isn't. */ 57 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3); 58 regcache_cooked_write_unsigned (regcache, 59 HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3); 60 } 61 62 /* An instruction to match. */ 63 struct insn_pattern 64 { 65 unsigned int data; /* See if it matches this.... */ 66 unsigned int mask; /* ... with this mask. */ 67 }; 68 69 static struct insn_pattern hppa_sigtramp[] = { 70 /* ldi 0, %r25 or ldi 1, %r25 */ 71 { 0x34190000, 0xfffffffd }, 72 /* ldi __NR_rt_sigreturn, %r20 */ 73 { 0x3414015a, 0xffffffff }, 74 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */ 75 { 0xe4008200, 0xffffffff }, 76 /* nop */ 77 { 0x08000240, 0xffffffff }, 78 { 0, 0 } 79 }; 80 81 #define HPPA_MAX_INSN_PATTERN_LEN (4) 82 83 /* Return non-zero if the instructions at PC match the series 84 described in PATTERN, or zero otherwise. PATTERN is an array of 85 'struct insn_pattern' objects, terminated by an entry whose mask is 86 zero. 87 88 When the match is successful, fill INSN[i] with what PATTERN[i] 89 matched. */ 90 static int 91 insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc, 92 struct insn_pattern *pattern, 93 unsigned int *insn) 94 { 95 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 96 int i; 97 CORE_ADDR npc = pc; 98 99 for (i = 0; pattern[i].mask; i++) 100 { 101 gdb_byte buf[4]; 102 103 target_read_memory (npc, buf, 4); 104 insn[i] = extract_unsigned_integer (buf, 4, byte_order); 105 if ((insn[i] & pattern[i].mask) == pattern[i].data) 106 npc += 4; 107 else 108 return 0; 109 } 110 return 1; 111 } 112 113 /* Signal frames. */ 114 115 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.) 116 117 Unfortunately, because of various bugs and changes to the kernel, 118 we have several cases to deal with. 119 120 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at 121 the beginning of the trampoline and struct rt_sigframe. 122 123 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at 124 the 4th word in the trampoline structure. This is wrong, it should point 125 at the 5th word. This is fixed in 2.6.5-rc2-pa4. 126 127 To detect these cases, we first take pc, align it to 64-bytes 128 to get the beginning of the signal frame, and then check offsets 0, 4 129 and 5 to see if we found the beginning of the trampoline. This will 130 tell us how to locate the sigcontext structure. 131 132 Note that with a 2.4 64-bit kernel, the signal context is not properly 133 passed back to userspace so the unwind will not work correctly. */ 134 static CORE_ADDR 135 hppa_linux_sigtramp_find_sigcontext (struct gdbarch *gdbarch, CORE_ADDR pc) 136 { 137 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN]; 138 int offs = 0; 139 int try; 140 /* offsets to try to find the trampoline */ 141 static int pcoffs[] = { 0, 4*4, 5*4 }; 142 /* offsets to the rt_sigframe structure */ 143 static int sfoffs[] = { 4*4, 10*4, 10*4 }; 144 CORE_ADDR sp; 145 146 /* Most of the time, this will be correct. The one case when this will 147 fail is if the user defined an alternate stack, in which case the 148 beginning of the stack will not be align_down (pc, 64). */ 149 sp = align_down (pc, 64); 150 151 /* rt_sigreturn trampoline: 152 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2) 153 3414015a ldi __NR_rt_sigreturn, %r20 154 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31 155 08000240 nop */ 156 157 for (try = 0; try < ARRAY_SIZE (pcoffs); try++) 158 { 159 if (insns_match_pattern (gdbarch, sp + pcoffs[try], 160 hppa_sigtramp, dummy)) 161 { 162 offs = sfoffs[try]; 163 break; 164 } 165 } 166 167 if (offs == 0) 168 { 169 if (insns_match_pattern (gdbarch, pc, hppa_sigtramp, dummy)) 170 { 171 /* sigaltstack case: we have no way of knowing which offset to 172 use in this case; default to new kernel handling. If this is 173 wrong the unwinding will fail. */ 174 try = 2; 175 sp = pc - pcoffs[try]; 176 } 177 else 178 { 179 return 0; 180 } 181 } 182 183 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains 184 a struct siginfo and a struct ucontext. struct ucontext contains 185 a struct sigcontext. Return an offset to this sigcontext here. Too 186 bad we cannot include system specific headers :-(. 187 sizeof(struct siginfo) == 128 188 offsetof(struct ucontext, uc_mcontext) == 24. */ 189 return sp + sfoffs[try] + 128 + 24; 190 } 191 192 struct hppa_linux_sigtramp_unwind_cache 193 { 194 CORE_ADDR base; 195 struct trad_frame_saved_reg *saved_regs; 196 }; 197 198 static struct hppa_linux_sigtramp_unwind_cache * 199 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame, 200 void **this_cache) 201 { 202 struct gdbarch *gdbarch = get_frame_arch (this_frame); 203 struct hppa_linux_sigtramp_unwind_cache *info; 204 CORE_ADDR pc, scptr; 205 int i; 206 207 if (*this_cache) 208 return *this_cache; 209 210 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache); 211 *this_cache = info; 212 info->saved_regs = trad_frame_alloc_saved_regs (this_frame); 213 214 pc = get_frame_pc (this_frame); 215 scptr = hppa_linux_sigtramp_find_sigcontext (gdbarch, pc); 216 217 /* structure of struct sigcontext: 218 219 struct sigcontext { 220 unsigned long sc_flags; 221 unsigned long sc_gr[32]; 222 unsigned long long sc_fr[32]; 223 unsigned long sc_iasq[2]; 224 unsigned long sc_iaoq[2]; 225 unsigned long sc_sar; */ 226 227 /* Skip sc_flags. */ 228 scptr += 4; 229 230 /* GR[0] is the psw. */ 231 info->saved_regs[HPPA_IPSW_REGNUM].addr = scptr; 232 scptr += 4; 233 234 /* General registers. */ 235 for (i = 1; i < 32; i++) 236 { 237 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; 238 scptr += 4; 239 } 240 241 /* Pad to long long boundary. */ 242 scptr += 4; 243 244 /* FP regs; FP0-3 are not restored. */ 245 scptr += (8 * 4); 246 247 for (i = 4; i < 32; i++) 248 { 249 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; 250 scptr += 4; 251 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; 252 scptr += 4; 253 } 254 255 /* IASQ/IAOQ. */ 256 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; 257 scptr += 4; 258 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; 259 scptr += 4; 260 261 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; 262 scptr += 4; 263 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; 264 scptr += 4; 265 266 info->saved_regs[HPPA_SAR_REGNUM].addr = scptr; 267 268 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM); 269 270 return info; 271 } 272 273 static void 274 hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame, 275 void **this_prologue_cache, 276 struct frame_id *this_id) 277 { 278 struct hppa_linux_sigtramp_unwind_cache *info 279 = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache); 280 *this_id = frame_id_build (info->base, get_frame_pc (this_frame)); 281 } 282 283 static struct value * 284 hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame, 285 void **this_prologue_cache, 286 int regnum) 287 { 288 struct hppa_linux_sigtramp_unwind_cache *info 289 = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache); 290 return hppa_frame_prev_register_helper (this_frame, 291 info->saved_regs, regnum); 292 } 293 294 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return 295 address should point to a signal trampoline on the stack. The signal 296 trampoline is embedded in a rt_sigframe structure that is aligned on 297 the stack. We take advantage of the fact that sp must be 64-byte aligned, 298 and the trampoline is small, so by rounding down the trampoline address 299 we can find the beginning of the struct rt_sigframe. */ 300 static int 301 hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self, 302 struct frame_info *this_frame, 303 void **this_prologue_cache) 304 { 305 struct gdbarch *gdbarch = get_frame_arch (this_frame); 306 CORE_ADDR pc = get_frame_pc (this_frame); 307 308 if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc)) 309 return 1; 310 311 return 0; 312 } 313 314 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { 315 SIGTRAMP_FRAME, 316 default_frame_unwind_stop_reason, 317 hppa_linux_sigtramp_frame_this_id, 318 hppa_linux_sigtramp_frame_prev_register, 319 NULL, 320 hppa_linux_sigtramp_frame_sniffer 321 }; 322 323 /* Attempt to find (and return) the global pointer for the given 324 function. 325 326 This is a rather nasty bit of code searchs for the .dynamic section 327 in the objfile corresponding to the pc of the function we're trying 328 to call. Once it finds the addresses at which the .dynamic section 329 lives in the child process, it scans the Elf32_Dyn entries for a 330 DT_PLTGOT tag. If it finds one of these, the corresponding 331 d_un.d_ptr value is the global pointer. */ 332 333 static CORE_ADDR 334 hppa_linux_find_global_pointer (struct gdbarch *gdbarch, 335 struct value *function) 336 { 337 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 338 struct obj_section *faddr_sect; 339 CORE_ADDR faddr; 340 341 faddr = value_as_address (function); 342 343 /* Is this a plabel? If so, dereference it to get the gp value. */ 344 if (faddr & 2) 345 { 346 int status; 347 gdb_byte buf[4]; 348 349 faddr &= ~3; 350 351 status = target_read_memory (faddr + 4, buf, sizeof (buf)); 352 if (status == 0) 353 return extract_unsigned_integer (buf, sizeof (buf), byte_order); 354 } 355 356 /* If the address is in the plt section, then the real function hasn't 357 yet been fixed up by the linker so we cannot determine the gp of 358 that function. */ 359 if (in_plt_section (faddr)) 360 return 0; 361 362 faddr_sect = find_pc_section (faddr); 363 if (faddr_sect != NULL) 364 { 365 struct obj_section *osect; 366 367 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) 368 { 369 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0) 370 break; 371 } 372 373 if (osect < faddr_sect->objfile->sections_end) 374 { 375 CORE_ADDR addr, endaddr; 376 377 addr = obj_section_addr (osect); 378 endaddr = obj_section_endaddr (osect); 379 380 while (addr < endaddr) 381 { 382 int status; 383 LONGEST tag; 384 gdb_byte buf[4]; 385 386 status = target_read_memory (addr, buf, sizeof (buf)); 387 if (status != 0) 388 break; 389 tag = extract_signed_integer (buf, sizeof (buf), byte_order); 390 391 if (tag == DT_PLTGOT) 392 { 393 CORE_ADDR global_pointer; 394 395 status = target_read_memory (addr + 4, buf, sizeof (buf)); 396 if (status != 0) 397 break; 398 global_pointer = extract_unsigned_integer (buf, sizeof (buf), 399 byte_order); 400 /* The payoff... */ 401 return global_pointer; 402 } 403 404 if (tag == DT_NULL) 405 break; 406 407 addr += 8; 408 } 409 } 410 } 411 return 0; 412 } 413 414 /* 415 * Registers saved in a coredump: 416 * gr0..gr31 417 * sr0..sr7 418 * iaoq0..iaoq1 419 * iasq0..iasq1 420 * sar, iir, isr, ior, ipsw 421 * cr0, cr24..cr31 422 * cr8,9,12,13 423 * cr10, cr15 424 */ 425 426 static const struct regcache_map_entry hppa_linux_gregmap[] = 427 { 428 { 32, HPPA_R0_REGNUM }, 429 { 1, HPPA_SR4_REGNUM+1 }, 430 { 1, HPPA_SR4_REGNUM+2 }, 431 { 1, HPPA_SR4_REGNUM+3 }, 432 { 1, HPPA_SR4_REGNUM+4 }, 433 { 1, HPPA_SR4_REGNUM }, 434 { 1, HPPA_SR4_REGNUM+5 }, 435 { 1, HPPA_SR4_REGNUM+6 }, 436 { 1, HPPA_SR4_REGNUM+7 }, 437 { 1, HPPA_PCOQ_HEAD_REGNUM }, 438 { 1, HPPA_PCOQ_TAIL_REGNUM }, 439 { 1, HPPA_PCSQ_HEAD_REGNUM }, 440 { 1, HPPA_PCSQ_TAIL_REGNUM }, 441 { 1, HPPA_SAR_REGNUM }, 442 { 1, HPPA_IIR_REGNUM }, 443 { 1, HPPA_ISR_REGNUM }, 444 { 1, HPPA_IOR_REGNUM }, 445 { 1, HPPA_IPSW_REGNUM }, 446 { 1, HPPA_RCR_REGNUM }, 447 { 8, HPPA_TR0_REGNUM }, 448 { 4, HPPA_PID0_REGNUM }, 449 { 1, HPPA_CCR_REGNUM }, 450 { 1, HPPA_EIEM_REGNUM }, 451 { 0 } 452 }; 453 454 static const struct regcache_map_entry hppa_linux_fpregmap[] = 455 { 456 /* FIXME: Only works for 32-bit mode. In 64-bit mode there should 457 be 32 fpregs, 8 bytes each. */ 458 { 64, HPPA_FP0_REGNUM, 4 }, 459 { 0 } 460 }; 461 462 /* HPPA Linux kernel register set. */ 463 static const struct regset hppa_linux_regset = 464 { 465 hppa_linux_gregmap, 466 regcache_supply_regset, regcache_collect_regset 467 }; 468 469 static const struct regset hppa_linux_fpregset = 470 { 471 hppa_linux_fpregmap, 472 regcache_supply_regset, regcache_collect_regset 473 }; 474 475 static void 476 hppa_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 477 iterate_over_regset_sections_cb *cb, 478 void *cb_data, 479 const struct regcache *regcache) 480 { 481 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 482 483 cb (".reg", 80 * tdep->bytes_per_address, &hppa_linux_regset, 484 NULL, cb_data); 485 cb (".reg2", 64 * 4, &hppa_linux_fpregset, NULL, cb_data); 486 } 487 488 489 /* Forward declarations. */ 490 extern initialize_file_ftype _initialize_hppa_linux_tdep; 491 492 static void 493 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 494 { 495 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 496 497 linux_init_abi (info, gdbarch); 498 499 /* GNU/Linux is always ELF. */ 500 tdep->is_elf = 1; 501 502 tdep->find_global_pointer = hppa_linux_find_global_pointer; 503 504 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); 505 506 frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind); 507 508 /* GNU/Linux uses SVR4-style shared libraries. */ 509 set_solib_svr4_fetch_link_map_offsets 510 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 511 512 tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline; 513 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); 514 515 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 516 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 517 518 /* On hppa-linux, currently, sizeof(long double) == 8. There has been 519 some discussions to support 128-bit long double, but it requires some 520 more work in gcc and glibc first. */ 521 set_gdbarch_long_double_bit (gdbarch, 64); 522 523 set_gdbarch_iterate_over_regset_sections 524 (gdbarch, hppa_linux_iterate_over_regset_sections); 525 526 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 527 528 /* Enable TLS support. */ 529 set_gdbarch_fetch_tls_load_module_address (gdbarch, 530 svr4_fetch_objfile_link_map); 531 } 532 533 void 534 _initialize_hppa_linux_tdep (void) 535 { 536 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, 537 hppa_linux_init_abi); 538 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, 539 GDB_OSABI_LINUX, hppa_linux_init_abi); 540 } 541