1/* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. 2 3 Copyright 2004 Free Software Foundation, Inc. 4 5This file is part of GDB. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 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 "hppa-tdep.h" 33 34#include "elf/common.h" 35 36#if 0 37/* Convert DWARF register number REG to the appropriate register 38 number used by GDB. */ 39static int 40hppa_dwarf_reg_to_regnum (int reg) 41{ 42 /* registers 0 - 31 are the same in both sets */ 43 if (reg < 32) 44 return reg; 45 46 /* dwarf regs 32 to 85 are fpregs 4 - 31 */ 47 if (reg >= 32 && reg <= 85) 48 return HPPA_FP4_REGNUM + (reg - 32); 49 50 warning ("Unmapped DWARF Register #%d encountered\n", reg); 51 return -1; 52} 53#endif 54 55static void 56hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid) 57{ 58 /* Probably this should be done by the kernel, but it isn't. */ 59 write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid); 60 write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid); 61} 62 63/* An instruction to match. */ 64struct insn_pattern 65{ 66 unsigned int data; /* See if it matches this.... */ 67 unsigned int mask; /* ... with this mask. */ 68}; 69 70/* See bfd/elf32-hppa.c */ 71static struct insn_pattern hppa_long_branch_stub[] = { 72 /* ldil LR'xxx,%r1 */ 73 { 0x20200000, 0xffe00000 }, 74 /* be,n RR'xxx(%sr4,%r1) */ 75 { 0xe0202002, 0xffe02002 }, 76 { 0, 0 } 77}; 78 79static struct insn_pattern hppa_long_branch_pic_stub[] = { 80 /* b,l .+8, %r1 */ 81 { 0xe8200000, 0xffe00000 }, 82 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */ 83 { 0x28200000, 0xffe00000 }, 84 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */ 85 { 0xe0202002, 0xffe02002 }, 86 { 0, 0 } 87}; 88 89static struct insn_pattern hppa_import_stub[] = { 90 /* addil LR'xxx, %dp */ 91 { 0x2b600000, 0xffe00000 }, 92 /* ldw RR'xxx(%r1), %r21 */ 93 { 0x48350000, 0xffffb000 }, 94 /* bv %r0(%r21) */ 95 { 0xeaa0c000, 0xffffffff }, 96 /* ldw RR'xxx+4(%r1), %r19 */ 97 { 0x48330000, 0xffffb000 }, 98 { 0, 0 } 99}; 100 101static struct insn_pattern hppa_import_pic_stub[] = { 102 /* addil LR'xxx,%r19 */ 103 { 0x2a600000, 0xffe00000 }, 104 /* ldw RR'xxx(%r1),%r21 */ 105 { 0x48350000, 0xffffb000 }, 106 /* bv %r0(%r21) */ 107 { 0xeaa0c000, 0xffffffff }, 108 /* ldw RR'xxx+4(%r1),%r19 */ 109 { 0x48330000, 0xffffb000 }, 110 { 0, 0 }, 111}; 112 113static struct insn_pattern hppa_plt_stub[] = { 114 /* b,l 1b, %r20 - 1b is 3 insns before here */ 115 { 0xea9f1fdd, 0xffffffff }, 116 /* depi 0,31,2,%r20 */ 117 { 0xd6801c1e, 0xffffffff }, 118 { 0, 0 } 119}; 120 121static struct insn_pattern hppa_sigtramp[] = { 122 /* ldi 0, %r25 or ldi 1, %r25 */ 123 { 0x34190000, 0xfffffffd }, 124 /* ldi __NR_rt_sigreturn, %r20 */ 125 { 0x3414015a, 0xffffffff }, 126 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */ 127 { 0xe4008200, 0xffffffff }, 128 /* nop */ 129 { 0x08000240, 0xffffffff }, 130 { 0, 0 } 131}; 132 133#define HPPA_MAX_INSN_PATTERN_LEN (4) 134 135/* Return non-zero if the instructions at PC match the series 136 described in PATTERN, or zero otherwise. PATTERN is an array of 137 'struct insn_pattern' objects, terminated by an entry whose mask is 138 zero. 139 140 When the match is successful, fill INSN[i] with what PATTERN[i] 141 matched. */ 142static int 143insns_match_pattern (CORE_ADDR pc, 144 struct insn_pattern *pattern, 145 unsigned int *insn) 146{ 147 int i; 148 CORE_ADDR npc = pc; 149 150 for (i = 0; pattern[i].mask; i++) 151 { 152 char buf[4]; 153 154 deprecated_read_memory_nobpt (npc, buf, 4); 155 insn[i] = extract_unsigned_integer (buf, 4); 156 if ((insn[i] & pattern[i].mask) == pattern[i].data) 157 npc += 4; 158 else 159 return 0; 160 } 161 return 1; 162} 163 164static int 165hppa_linux_in_dyncall (CORE_ADDR pc) 166{ 167 return pc == hppa_symbol_address("$$dyncall"); 168} 169 170/* There are several kinds of "trampolines" that we need to deal with: 171 - long branch stubs: these are inserted by the linker when a branch 172 target is too far away for a branch insn to reach 173 - plt stubs: these should go into the .plt section, so are easy to find 174 - import stubs: used to call from object to shared lib or shared lib to 175 shared lib; these go in regular text sections. In fact the linker tries 176 to put them throughout the code because branches have limited reachability. 177 We use the same mechanism as ppc64 to recognize the stub insn patterns. 178 - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function 179 calls. $$dyncall is exported by libgcc.a */ 180static int 181hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name) 182{ 183 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN]; 184 int r; 185 186 r = in_plt_section (pc, name) 187 || hppa_linux_in_dyncall (pc) 188 || insns_match_pattern (pc, hppa_import_stub, insn) 189 || insns_match_pattern (pc, hppa_import_pic_stub, insn) 190 || insns_match_pattern (pc, hppa_long_branch_stub, insn) 191 || insns_match_pattern (pc, hppa_long_branch_pic_stub, insn); 192 193 return r; 194} 195 196static CORE_ADDR 197hppa_linux_skip_trampoline_code (CORE_ADDR pc) 198{ 199 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN]; 200 int dp_rel, pic_rel; 201 202 /* dyncall handles both PLABELs and direct addresses */ 203 if (hppa_linux_in_dyncall (pc)) 204 { 205 pc = (CORE_ADDR) read_register (22); 206 207 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */ 208 if (pc & 0x2) 209 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); 210 211 return pc; 212 } 213 214 dp_rel = pic_rel = 0; 215 if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn)) 216 || (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn))) 217 { 218 /* Extract the target address from the addil/ldw sequence. */ 219 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]); 220 221 if (dp_rel) 222 pc += (CORE_ADDR) read_register (27); 223 else 224 pc += (CORE_ADDR) read_register (19); 225 226 /* fallthrough */ 227 } 228 229 if (in_plt_section (pc, NULL)) 230 { 231 pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8); 232 233 /* if the plt slot has not yet been resolved, the target will 234 be the plt stub */ 235 if (in_plt_section (pc, NULL)) 236 { 237 /* Sanity check: are we pointing to the plt stub? */ 238 if (insns_match_pattern (pc, hppa_plt_stub, insn)) 239 { 240 /* this should point to the fixup routine */ 241 pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8); 242 } 243 else 244 { 245 error ("Cannot resolve plt stub at 0x%s\n", 246 paddr_nz (pc)); 247 pc = 0; 248 } 249 } 250 } 251 252 return pc; 253} 254 255/* Signal frames. */ 256 257/* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.) 258 259 Unfortunately, because of various bugs and changes to the kernel, 260 we have several cases to deal with. 261 262 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at 263 the beginning of the trampoline and struct rt_sigframe. 264 265 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at 266 the 4th word in the trampoline structure. This is wrong, it should point 267 at the 5th word. This is fixed in 2.6.5-rc2-pa4. 268 269 To detect these cases, we first take pc, align it to 64-bytes 270 to get the beginning of the signal frame, and then check offsets 0, 4 271 and 5 to see if we found the beginning of the trampoline. This will 272 tell us how to locate the sigcontext structure. 273 274 Note that with a 2.4 64-bit kernel, the signal context is not properly 275 passed back to userspace so the unwind will not work correctly. */ 276static CORE_ADDR 277hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc) 278{ 279 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN]; 280 int offs = 0; 281 int try; 282 /* offsets to try to find the trampoline */ 283 static int pcoffs[] = { 0, 4*4, 5*4 }; 284 /* offsets to the rt_sigframe structure */ 285 static int sfoffs[] = { 4*4, 10*4, 10*4 }; 286 CORE_ADDR sp; 287 288 /* Most of the time, this will be correct. The one case when this will 289 fail is if the user defined an alternate stack, in which case the 290 beginning of the stack will not be align_down (pc, 64). */ 291 sp = align_down (pc, 64); 292 293 /* rt_sigreturn trampoline: 294 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2) 295 3414015a ldi __NR_rt_sigreturn, %r20 296 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31 297 08000240 nop */ 298 299 for (try = 0; try < ARRAY_SIZE (pcoffs); try++) 300 { 301 if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy)) 302 { 303 offs = sfoffs[try]; 304 break; 305 } 306 } 307 308 if (offs == 0) 309 { 310 if (insns_match_pattern (pc, hppa_sigtramp, dummy)) 311 { 312 /* sigaltstack case: we have no way of knowing which offset to 313 use in this case; default to new kernel handling. If this is 314 wrong the unwinding will fail. */ 315 try = 2; 316 sp = pc - pcoffs[try]; 317 } 318 else 319 { 320 return 0; 321 } 322 } 323 324 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains 325 a struct siginfo and a struct ucontext. struct ucontext contains 326 a struct sigcontext. Return an offset to this sigcontext here. Too 327 bad we cannot include system specific headers :-(. 328 sizeof(struct siginfo) == 128 329 offsetof(struct ucontext, uc_mcontext) == 24. */ 330 return sp + sfoffs[try] + 128 + 24; 331} 332 333struct hppa_linux_sigtramp_unwind_cache 334{ 335 CORE_ADDR base; 336 struct trad_frame_saved_reg *saved_regs; 337}; 338 339static struct hppa_linux_sigtramp_unwind_cache * 340hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame, 341 void **this_cache) 342{ 343 struct gdbarch *gdbarch = get_frame_arch (next_frame); 344 struct hppa_linux_sigtramp_unwind_cache *info; 345 CORE_ADDR pc, scptr; 346 int i; 347 348 if (*this_cache) 349 return *this_cache; 350 351 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache); 352 *this_cache = info; 353 info->saved_regs = trad_frame_alloc_saved_regs (next_frame); 354 355 pc = frame_pc_unwind (next_frame); 356 scptr = hppa_linux_sigtramp_find_sigcontext (pc); 357 358 /* structure of struct sigcontext: 359 360 struct sigcontext { 361 unsigned long sc_flags; 362 unsigned long sc_gr[32]; 363 unsigned long long sc_fr[32]; 364 unsigned long sc_iasq[2]; 365 unsigned long sc_iaoq[2]; 366 unsigned long sc_sar; */ 367 368 /* Skip sc_flags. */ 369 scptr += 4; 370 371 /* GR[0] is the psw, we don't restore that. */ 372 scptr += 4; 373 374 /* General registers. */ 375 for (i = 1; i < 32; i++) 376 { 377 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; 378 scptr += 4; 379 } 380 381 /* Pad. */ 382 scptr += 4; 383 384 /* FP regs; FP0-3 are not restored. */ 385 scptr += (8 * 4); 386 387 for (i = 4; i < 32; i++) 388 { 389 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; 390 scptr += 4; 391 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; 392 scptr += 4; 393 } 394 395 /* IASQ/IAOQ. */ 396 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; 397 scptr += 4; 398 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; 399 scptr += 4; 400 401 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; 402 scptr += 4; 403 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; 404 scptr += 4; 405 406 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM); 407 408 return info; 409} 410 411static void 412hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame, 413 void **this_prologue_cache, 414 struct frame_id *this_id) 415{ 416 struct hppa_linux_sigtramp_unwind_cache *info 417 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); 418 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame)); 419} 420 421static void 422hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame, 423 void **this_prologue_cache, 424 int regnum, int *optimizedp, 425 enum lval_type *lvalp, 426 CORE_ADDR *addrp, 427 int *realnump, void *valuep) 428{ 429 struct hppa_linux_sigtramp_unwind_cache *info 430 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); 431 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum, 432 optimizedp, lvalp, addrp, realnump, valuep); 433} 434 435static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { 436 SIGTRAMP_FRAME, 437 hppa_linux_sigtramp_frame_this_id, 438 hppa_linux_sigtramp_frame_prev_register 439}; 440 441/* hppa-linux always uses "new-style" rt-signals. The signal handler's return 442 address should point to a signal trampoline on the stack. The signal 443 trampoline is embedded in a rt_sigframe structure that is aligned on 444 the stack. We take advantage of the fact that sp must be 64-byte aligned, 445 and the trampoline is small, so by rounding down the trampoline address 446 we can find the beginning of the struct rt_sigframe. */ 447static const struct frame_unwind * 448hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame) 449{ 450 CORE_ADDR pc = frame_pc_unwind (next_frame); 451 452 if (hppa_linux_sigtramp_find_sigcontext (pc)) 453 return &hppa_linux_sigtramp_frame_unwind; 454 455 return NULL; 456} 457 458/* Attempt to find (and return) the global pointer for the given 459 function. 460 461 This is a rather nasty bit of code searchs for the .dynamic section 462 in the objfile corresponding to the pc of the function we're trying 463 to call. Once it finds the addresses at which the .dynamic section 464 lives in the child process, it scans the Elf32_Dyn entries for a 465 DT_PLTGOT tag. If it finds one of these, the corresponding 466 d_un.d_ptr value is the global pointer. */ 467 468static CORE_ADDR 469hppa_linux_find_global_pointer (struct value *function) 470{ 471 struct obj_section *faddr_sect; 472 CORE_ADDR faddr; 473 474 faddr = value_as_address (function); 475 476 /* Is this a plabel? If so, dereference it to get the gp value. */ 477 if (faddr & 2) 478 { 479 int status; 480 char buf[4]; 481 482 faddr &= ~3; 483 484 status = target_read_memory (faddr + 4, buf, sizeof (buf)); 485 if (status == 0) 486 return extract_unsigned_integer (buf, sizeof (buf)); 487 } 488 489 /* If the address is in the plt section, then the real function hasn't 490 yet been fixed up by the linker so we cannot determine the gp of 491 that function. */ 492 if (in_plt_section (faddr, NULL)) 493 return 0; 494 495 faddr_sect = find_pc_section (faddr); 496 if (faddr_sect != NULL) 497 { 498 struct obj_section *osect; 499 500 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) 501 { 502 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0) 503 break; 504 } 505 506 if (osect < faddr_sect->objfile->sections_end) 507 { 508 CORE_ADDR addr; 509 510 addr = osect->addr; 511 while (addr < osect->endaddr) 512 { 513 int status; 514 LONGEST tag; 515 char buf[4]; 516 517 status = target_read_memory (addr, buf, sizeof (buf)); 518 if (status != 0) 519 break; 520 tag = extract_signed_integer (buf, sizeof (buf)); 521 522 if (tag == DT_PLTGOT) 523 { 524 CORE_ADDR global_pointer; 525 526 status = target_read_memory (addr + 4, buf, sizeof (buf)); 527 if (status != 0) 528 break; 529 global_pointer = extract_unsigned_integer (buf, sizeof (buf)); 530 531 /* The payoff... */ 532 return global_pointer; 533 } 534 535 if (tag == DT_NULL) 536 break; 537 538 addr += 8; 539 } 540 } 541 } 542 return 0; 543} 544 545/* Forward declarations. */ 546extern initialize_file_ftype _initialize_hppa_linux_tdep; 547 548static void 549hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 550{ 551 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 552 553 /* GNU/Linux is always ELF. */ 554 tdep->is_elf = 1; 555 556 tdep->find_global_pointer = hppa_linux_find_global_pointer; 557 558 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); 559 560 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer); 561 562 /* GNU/Linux uses SVR4-style shared libraries. */ 563 set_solib_svr4_fetch_link_map_offsets 564 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 565 566 set_gdbarch_in_solib_call_trampoline 567 (gdbarch, hppa_linux_in_solib_call_trampoline); 568 set_gdbarch_skip_trampoline_code 569 (gdbarch, hppa_linux_skip_trampoline_code); 570 571 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 572 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 573 574 /* On hppa-linux, currently, sizeof(long double) == 8. There has been 575 some discussions to support 128-bit long double, but it requires some 576 more work in gcc and glibc first. */ 577 set_gdbarch_long_double_bit (gdbarch, 64); 578 579#if 0 580 /* Dwarf-2 unwinding support. Not yet working. */ 581 set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 582 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); 583 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); 584 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer); 585#endif 586} 587 588void 589_initialize_hppa_linux_tdep (void) 590{ 591 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi); 592} 593