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