1/* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. 2 3 Copyright (C) 2004, 2006, 2007 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 35#include "elf/common.h" 36 37#if 0 38/* Convert DWARF register number REG to the appropriate register 39 number used by GDB. */ 40static int 41hppa_dwarf_reg_to_regnum (int reg) 42{ 43 /* registers 0 - 31 are the same in both sets */ 44 if (reg < 32) 45 return reg; 46 47 /* dwarf regs 32 to 85 are fpregs 4 - 31 */ 48 if (reg >= 32 && reg <= 85) 49 return HPPA_FP4_REGNUM + (reg - 32); 50 51 warning (_("Unmapped DWARF Register #%d encountered."), reg); 52 return -1; 53} 54#endif 55 56static void 57hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v) 58{ 59 /* Probably this should be done by the kernel, but it isn't. */ 60 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3); 61 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3); 62} 63 64/* An instruction to match. */ 65struct insn_pattern 66{ 67 unsigned int data; /* See if it matches this.... */ 68 unsigned int mask; /* ... with this mask. */ 69}; 70 71static struct insn_pattern hppa_sigtramp[] = { 72 /* ldi 0, %r25 or ldi 1, %r25 */ 73 { 0x34190000, 0xfffffffd }, 74 /* ldi __NR_rt_sigreturn, %r20 */ 75 { 0x3414015a, 0xffffffff }, 76 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */ 77 { 0xe4008200, 0xffffffff }, 78 /* nop */ 79 { 0x08000240, 0xffffffff }, 80 { 0, 0 } 81}; 82 83#define HPPA_MAX_INSN_PATTERN_LEN (4) 84 85/* Return non-zero if the instructions at PC match the series 86 described in PATTERN, or zero otherwise. PATTERN is an array of 87 'struct insn_pattern' objects, terminated by an entry whose mask is 88 zero. 89 90 When the match is successful, fill INSN[i] with what PATTERN[i] 91 matched. */ 92static int 93insns_match_pattern (CORE_ADDR pc, 94 struct insn_pattern *pattern, 95 unsigned int *insn) 96{ 97 int i; 98 CORE_ADDR npc = pc; 99 100 for (i = 0; pattern[i].mask; i++) 101 { 102 char buf[4]; 103 104 read_memory_nobpt (npc, buf, 4); 105 insn[i] = extract_unsigned_integer (buf, 4); 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. */ 135static CORE_ADDR 136hppa_linux_sigtramp_find_sigcontext (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 (sp + pcoffs[try], hppa_sigtramp, dummy)) 161 { 162 offs = sfoffs[try]; 163 break; 164 } 165 } 166 167 if (offs == 0) 168 { 169 if (insns_match_pattern (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 192struct hppa_linux_sigtramp_unwind_cache 193{ 194 CORE_ADDR base; 195 struct trad_frame_saved_reg *saved_regs; 196}; 197 198static struct hppa_linux_sigtramp_unwind_cache * 199hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame, 200 void **this_cache) 201{ 202 struct gdbarch *gdbarch = get_frame_arch (next_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 (next_frame); 213 214 pc = frame_pc_unwind (next_frame); 215 scptr = hppa_linux_sigtramp_find_sigcontext (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, we don't restore that. */ 231 scptr += 4; 232 233 /* General registers. */ 234 for (i = 1; i < 32; i++) 235 { 236 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; 237 scptr += 4; 238 } 239 240 /* Pad. */ 241 scptr += 4; 242 243 /* FP regs; FP0-3 are not restored. */ 244 scptr += (8 * 4); 245 246 for (i = 4; i < 32; i++) 247 { 248 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; 249 scptr += 4; 250 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; 251 scptr += 4; 252 } 253 254 /* IASQ/IAOQ. */ 255 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; 256 scptr += 4; 257 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; 258 scptr += 4; 259 260 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; 261 scptr += 4; 262 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; 263 scptr += 4; 264 265 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM); 266 267 return info; 268} 269 270static void 271hppa_linux_sigtramp_frame_this_id (struct frame_info *next_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 (next_frame, this_prologue_cache); 277 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame)); 278} 279 280static void 281hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame, 282 void **this_prologue_cache, 283 int regnum, int *optimizedp, 284 enum lval_type *lvalp, 285 CORE_ADDR *addrp, 286 int *realnump, gdb_byte *valuep) 287{ 288 struct hppa_linux_sigtramp_unwind_cache *info 289 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); 290 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum, 291 optimizedp, lvalp, addrp, realnump, valuep); 292} 293 294static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { 295 SIGTRAMP_FRAME, 296 hppa_linux_sigtramp_frame_this_id, 297 hppa_linux_sigtramp_frame_prev_register 298}; 299 300/* hppa-linux always uses "new-style" rt-signals. The signal handler's return 301 address should point to a signal trampoline on the stack. The signal 302 trampoline is embedded in a rt_sigframe structure that is aligned on 303 the stack. We take advantage of the fact that sp must be 64-byte aligned, 304 and the trampoline is small, so by rounding down the trampoline address 305 we can find the beginning of the struct rt_sigframe. */ 306static const struct frame_unwind * 307hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame) 308{ 309 CORE_ADDR pc = frame_pc_unwind (next_frame); 310 311 if (hppa_linux_sigtramp_find_sigcontext (pc)) 312 return &hppa_linux_sigtramp_frame_unwind; 313 314 return NULL; 315} 316 317/* Attempt to find (and return) the global pointer for the given 318 function. 319 320 This is a rather nasty bit of code searchs for the .dynamic section 321 in the objfile corresponding to the pc of the function we're trying 322 to call. Once it finds the addresses at which the .dynamic section 323 lives in the child process, it scans the Elf32_Dyn entries for a 324 DT_PLTGOT tag. If it finds one of these, the corresponding 325 d_un.d_ptr value is the global pointer. */ 326 327static CORE_ADDR 328hppa_linux_find_global_pointer (struct value *function) 329{ 330 struct obj_section *faddr_sect; 331 CORE_ADDR faddr; 332 333 faddr = value_as_address (function); 334 335 /* Is this a plabel? If so, dereference it to get the gp value. */ 336 if (faddr & 2) 337 { 338 int status; 339 char buf[4]; 340 341 faddr &= ~3; 342 343 status = target_read_memory (faddr + 4, buf, sizeof (buf)); 344 if (status == 0) 345 return extract_unsigned_integer (buf, sizeof (buf)); 346 } 347 348 /* If the address is in the plt section, then the real function hasn't 349 yet been fixed up by the linker so we cannot determine the gp of 350 that function. */ 351 if (in_plt_section (faddr, NULL)) 352 return 0; 353 354 faddr_sect = find_pc_section (faddr); 355 if (faddr_sect != NULL) 356 { 357 struct obj_section *osect; 358 359 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) 360 { 361 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0) 362 break; 363 } 364 365 if (osect < faddr_sect->objfile->sections_end) 366 { 367 CORE_ADDR addr; 368 369 addr = osect->addr; 370 while (addr < osect->endaddr) 371 { 372 int status; 373 LONGEST tag; 374 char buf[4]; 375 376 status = target_read_memory (addr, buf, sizeof (buf)); 377 if (status != 0) 378 break; 379 tag = extract_signed_integer (buf, sizeof (buf)); 380 381 if (tag == DT_PLTGOT) 382 { 383 CORE_ADDR global_pointer; 384 385 status = target_read_memory (addr + 4, buf, sizeof (buf)); 386 if (status != 0) 387 break; 388 global_pointer = extract_unsigned_integer (buf, sizeof (buf)); 389 390 /* The payoff... */ 391 return global_pointer; 392 } 393 394 if (tag == DT_NULL) 395 break; 396 397 addr += 8; 398 } 399 } 400 } 401 return 0; 402} 403 404/* 405 * Registers saved in a coredump: 406 * gr0..gr31 407 * sr0..sr7 408 * iaoq0..iaoq1 409 * iasq0..iasq1 410 * sar, iir, isr, ior, ipsw 411 * cr0, cr24..cr31 412 * cr8,9,12,13 413 * cr10, cr15 414 */ 415 416#define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n) 417#define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n) 418static const int greg_map[] = 419 { 420 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3), 421 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7), 422 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11), 423 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15), 424 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19), 425 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23), 426 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27), 427 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31), 428 429 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4, 430 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7, 431 432 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM, 433 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM, 434 435 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM, 436 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM, 437 438 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3), 439 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7), 440 441 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM, 442 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM, 443 }; 444 445static void 446hppa_linux_supply_regset (const struct regset *regset, 447 struct regcache *regcache, 448 int regnum, const void *regs, size_t len) 449{ 450 struct gdbarch *arch = get_regcache_arch (regcache); 451 struct gdbarch_tdep *tdep = gdbarch_tdep (arch); 452 const char *buf = regs; 453 int i, offset; 454 455 offset = 0; 456 for (i = 0; i < ARRAY_SIZE (greg_map); i++) 457 { 458 if (regnum == greg_map[i] || regnum == -1) 459 regcache_raw_supply (regcache, greg_map[i], buf + offset); 460 461 offset += tdep->bytes_per_address; 462 } 463} 464 465static void 466hppa_linux_supply_fpregset (const struct regset *regset, 467 struct regcache *regcache, 468 int regnum, const void *regs, size_t len) 469{ 470 const char *buf = regs; 471 int i, offset; 472 473 offset = 0; 474 for (i = 0; i < 31; i++) 475 { 476 if (regnum == HPPA_FP0_REGNUM + i || regnum == -1) 477 regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i, 478 buf + offset); 479 offset += 8; 480 } 481} 482 483/* HPPA Linux kernel register set. */ 484static struct regset hppa_linux_regset = 485{ 486 NULL, 487 hppa_linux_supply_regset 488}; 489 490static struct regset hppa_linux_fpregset = 491{ 492 NULL, 493 hppa_linux_supply_fpregset 494}; 495 496static const struct regset * 497hppa_linux_regset_from_core_section (struct gdbarch *gdbarch, 498 const char *sect_name, 499 size_t sect_size) 500{ 501 if (strcmp (sect_name, ".reg") == 0) 502 return &hppa_linux_regset; 503 else if (strcmp (sect_name, ".reg2") == 0) 504 return &hppa_linux_fpregset; 505 506 return NULL; 507} 508 509 510/* Forward declarations. */ 511extern initialize_file_ftype _initialize_hppa_linux_tdep; 512 513static void 514hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 515{ 516 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 517 518 /* GNU/Linux is always ELF. */ 519 tdep->is_elf = 1; 520 521 tdep->find_global_pointer = hppa_linux_find_global_pointer; 522 523 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); 524 525 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer); 526 527 /* GNU/Linux uses SVR4-style shared libraries. */ 528 set_solib_svr4_fetch_link_map_offsets 529 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 530 531 tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline; 532 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); 533 534 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 535 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 536 537 /* On hppa-linux, currently, sizeof(long double) == 8. There has been 538 some discussions to support 128-bit long double, but it requires some 539 more work in gcc and glibc first. */ 540 set_gdbarch_long_double_bit (gdbarch, 64); 541 542 set_gdbarch_regset_from_core_section 543 (gdbarch, hppa_linux_regset_from_core_section); 544 545#if 0 546 /* Dwarf-2 unwinding support. Not yet working. */ 547 set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 548 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 549 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); 550 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer); 551#endif 552 553 /* Enable TLS support. */ 554 set_gdbarch_fetch_tls_load_module_address (gdbarch, 555 svr4_fetch_objfile_link_map); 556} 557 558void 559_initialize_hppa_linux_tdep (void) 560{ 561 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi); 562 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi); 563} 564