1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
3 Copyright 2004 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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"
32 #include "hppa-tdep.h"
34 #include "elf/common.h"
37 /* Convert DWARF register number REG to the appropriate register
38 number used by GDB. */
40 hppa_dwarf_reg_to_regnum (int reg)
42 /* registers 0 - 31 are the same in both sets */
46 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
47 if (reg >= 32 && reg <= 85)
48 return HPPA_FP4_REGNUM + (reg - 32);
50 warning ("Unmapped DWARF Register #%d encountered\n", reg);
56 hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
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);
63 /* An instruction to match. */
66 unsigned int data; /* See if it matches this.... */
67 unsigned int mask; /* ... with this mask. */
70 /* See bfd/elf32-hppa.c */
71 static struct insn_pattern hppa_long_branch_stub[] = {
73 { 0x20200000, 0xffe00000 },
74 /* be,n RR'xxx(%sr4,%r1) */
75 { 0xe0202002, 0xffe02002 },
79 static struct insn_pattern hppa_long_branch_pic_stub[] = {
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 },
89 static struct insn_pattern hppa_import_stub[] = {
90 /* addil LR'xxx, %dp */
91 { 0x2b600000, 0xffe00000 },
92 /* ldw RR'xxx(%r1), %r21 */
93 { 0x48350000, 0xffffb000 },
95 { 0xeaa0c000, 0xffffffff },
96 /* ldw RR'xxx+4(%r1), %r19 */
97 { 0x48330000, 0xffffb000 },
101 static struct insn_pattern hppa_import_pic_stub[] = {
102 /* addil LR'xxx,%r19 */
103 { 0x2a600000, 0xffe00000 },
104 /* ldw RR'xxx(%r1),%r21 */
105 { 0x48350000, 0xffffb000 },
107 { 0xeaa0c000, 0xffffffff },
108 /* ldw RR'xxx+4(%r1),%r19 */
109 { 0x48330000, 0xffffb000 },
113 static 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 },
121 static 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 },
129 { 0x08000240, 0xffffffff },
133 #define HPPA_MAX_INSN_PATTERN_LEN (4)
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
140 When the match is successful, fill INSN[i] with what PATTERN[i]
143 insns_match_pattern (CORE_ADDR pc,
144 struct insn_pattern *pattern,
150 for (i = 0; pattern[i].mask; i++)
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)
165 hppa_linux_in_dyncall (CORE_ADDR pc)
167 return pc == hppa_symbol_address("$$dyncall");
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 */
181 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
183 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
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);
197 hppa_linux_skip_trampoline_code (CORE_ADDR pc)
199 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
202 /* dyncall handles both PLABELs and direct addresses */
203 if (hppa_linux_in_dyncall (pc))
205 pc = (CORE_ADDR) read_register (22);
207 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
209 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
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)))
218 /* Extract the target address from the addil/ldw sequence. */
219 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
222 pc += (CORE_ADDR) read_register (27);
224 pc += (CORE_ADDR) read_register (19);
229 if (in_plt_section (pc, NULL))
231 pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8);
233 /* if the plt slot has not yet been resolved, the target will
235 if (in_plt_section (pc, NULL))
237 /* Sanity check: are we pointing to the plt stub? */
238 if (insns_match_pattern (pc, hppa_plt_stub, insn))
240 /* this should point to the fixup routine */
241 pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8);
245 error ("Cannot resolve plt stub at 0x%s\n",
257 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
259 Unfortunately, because of various bugs and changes to the kernel,
260 we have several cases to deal with.
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.
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.
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.
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. */
277 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
279 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
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 };
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);
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
299 for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
301 if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
310 if (insns_match_pattern (pc, hppa_sigtramp, dummy))
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. */
316 sp = pc - pcoffs[try];
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;
333 struct hppa_linux_sigtramp_unwind_cache
336 struct trad_frame_saved_reg *saved_regs;
339 static struct hppa_linux_sigtramp_unwind_cache *
340 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
343 struct gdbarch *gdbarch = get_frame_arch (next_frame);
344 struct hppa_linux_sigtramp_unwind_cache *info;
351 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
353 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
355 pc = frame_pc_unwind (next_frame);
356 scptr = hppa_linux_sigtramp_find_sigcontext (pc);
358 /* structure of 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; */
371 /* GR[0] is the psw, we don't restore that. */
374 /* General registers. */
375 for (i = 1; i < 32; i++)
377 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
384 /* FP regs; FP0-3 are not restored. */
387 for (i = 4; i < 32; i++)
389 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
391 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
396 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
398 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
401 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
403 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
406 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
412 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
413 void **this_prologue_cache,
414 struct frame_id *this_id)
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));
422 hppa_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,
427 int *realnump, void *valuep)
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);
435 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
437 hppa_linux_sigtramp_frame_this_id,
438 hppa_linux_sigtramp_frame_prev_register
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. */
447 static const struct frame_unwind *
448 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
450 CORE_ADDR pc = frame_pc_unwind (next_frame);
452 if (hppa_linux_sigtramp_find_sigcontext (pc))
453 return &hppa_linux_sigtramp_frame_unwind;
458 /* Attempt to find (and return) the global pointer for the given
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. */
469 hppa_linux_find_global_pointer (struct value *function)
471 struct obj_section *faddr_sect;
474 faddr = value_as_address (function);
476 /* Is this a plabel? If so, dereference it to get the gp value. */
484 status = target_read_memory (faddr + 4, buf, sizeof (buf));
486 return extract_unsigned_integer (buf, sizeof (buf));
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
492 if (in_plt_section (faddr, NULL))
495 faddr_sect = find_pc_section (faddr);
496 if (faddr_sect != NULL)
498 struct obj_section *osect;
500 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
502 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
506 if (osect < faddr_sect->objfile->sections_end)
511 while (addr < osect->endaddr)
517 status = target_read_memory (addr, buf, sizeof (buf));
520 tag = extract_signed_integer (buf, sizeof (buf));
522 if (tag == DT_PLTGOT)
524 CORE_ADDR global_pointer;
526 status = target_read_memory (addr + 4, buf, sizeof (buf));
529 global_pointer = extract_unsigned_integer (buf, sizeof (buf));
532 return global_pointer;
545 /* Forward declarations. */
546 extern initialize_file_ftype _initialize_hppa_linux_tdep;
549 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
551 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
553 /* GNU/Linux is always ELF. */
556 tdep->find_global_pointer = hppa_linux_find_global_pointer;
558 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
560 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
562 /* GNU/Linux uses SVR4-style shared libraries. */
563 set_solib_svr4_fetch_link_map_offsets
564 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
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);
571 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
572 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
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);
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);
589 _initialize_hppa_linux_tdep (void)
591 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);