1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. 2 3 Copyright (C) 2004-2014 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 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n) 427 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n) 428 static const int greg_map[] = 429 { 430 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3), 431 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7), 432 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11), 433 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15), 434 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19), 435 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23), 436 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27), 437 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31), 438 439 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4, 440 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7, 441 442 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM, 443 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM, 444 445 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM, 446 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM, 447 448 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3), 449 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7), 450 451 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM, 452 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM, 453 }; 454 455 static void 456 hppa_linux_supply_regset (const struct regset *regset, 457 struct regcache *regcache, 458 int regnum, const void *regs, size_t len) 459 { 460 struct gdbarch *arch = get_regcache_arch (regcache); 461 struct gdbarch_tdep *tdep = gdbarch_tdep (arch); 462 const char *buf = regs; 463 int i, offset; 464 465 offset = 0; 466 for (i = 0; i < ARRAY_SIZE (greg_map); i++) 467 { 468 if (regnum == greg_map[i] || regnum == -1) 469 regcache_raw_supply (regcache, greg_map[i], buf + offset); 470 471 offset += tdep->bytes_per_address; 472 } 473 } 474 475 static void 476 hppa_linux_supply_fpregset (const struct regset *regset, 477 struct regcache *regcache, 478 int regnum, const void *regs, size_t len) 479 { 480 const char *buf = regs; 481 int i, offset; 482 483 offset = 0; 484 for (i = 0; i < 64; i++) 485 { 486 if (regnum == HPPA_FP0_REGNUM + i || regnum == -1) 487 regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i, 488 buf + offset); 489 offset += 4; 490 } 491 } 492 493 /* HPPA Linux kernel register set. */ 494 static struct regset hppa_linux_regset = 495 { 496 NULL, 497 hppa_linux_supply_regset 498 }; 499 500 static struct regset hppa_linux_fpregset = 501 { 502 NULL, 503 hppa_linux_supply_fpregset 504 }; 505 506 static const struct regset * 507 hppa_linux_regset_from_core_section (struct gdbarch *gdbarch, 508 const char *sect_name, 509 size_t sect_size) 510 { 511 if (strcmp (sect_name, ".reg") == 0) 512 return &hppa_linux_regset; 513 else if (strcmp (sect_name, ".reg2") == 0) 514 return &hppa_linux_fpregset; 515 516 return NULL; 517 } 518 519 520 /* Forward declarations. */ 521 extern initialize_file_ftype _initialize_hppa_linux_tdep; 522 523 static void 524 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 525 { 526 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 527 528 linux_init_abi (info, gdbarch); 529 530 /* GNU/Linux is always ELF. */ 531 tdep->is_elf = 1; 532 533 tdep->find_global_pointer = hppa_linux_find_global_pointer; 534 535 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); 536 537 frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind); 538 539 /* GNU/Linux uses SVR4-style shared libraries. */ 540 set_solib_svr4_fetch_link_map_offsets 541 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 542 543 tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline; 544 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); 545 546 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 547 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 548 549 /* On hppa-linux, currently, sizeof(long double) == 8. There has been 550 some discussions to support 128-bit long double, but it requires some 551 more work in gcc and glibc first. */ 552 set_gdbarch_long_double_bit (gdbarch, 64); 553 554 set_gdbarch_regset_from_core_section 555 (gdbarch, hppa_linux_regset_from_core_section); 556 557 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 558 559 /* Enable TLS support. */ 560 set_gdbarch_fetch_tls_load_module_address (gdbarch, 561 svr4_fetch_objfile_link_map); 562 } 563 564 void 565 _initialize_hppa_linux_tdep (void) 566 { 567 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, 568 hppa_linux_init_abi); 569 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, 570 GDB_OSABI_LINUX, hppa_linux_init_abi); 571 } 572