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