1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
3 Copyright (C) 2004, 2006, 2007 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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
27 #include "solib-svr4.h"
28 #include "glibc-tdep.h"
29 #include "frame-unwind.h"
30 #include "trad-frame.h"
31 #include "dwarf2-frame.h"
35 #include "hppa-tdep.h"
37 #include "elf/common.h"
40 /* Convert DWARF register number REG to the appropriate register
41 number used by GDB. */
43 hppa_dwarf_reg_to_regnum (int reg)
45 /* registers 0 - 31 are the same in both sets */
49 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
50 if (reg >= 32 && reg <= 85)
51 return HPPA_FP4_REGNUM + (reg - 32);
53 warning (_("Unmapped DWARF Register #%d encountered."), reg);
59 hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
61 /* Probably this should be done by the kernel, but it isn't. */
62 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
63 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
66 /* An instruction to match. */
69 unsigned int data; /* See if it matches this.... */
70 unsigned int mask; /* ... with this mask. */
73 static struct insn_pattern hppa_sigtramp[] = {
74 /* ldi 0, %r25 or ldi 1, %r25 */
75 { 0x34190000, 0xfffffffd },
76 /* ldi __NR_rt_sigreturn, %r20 */
77 { 0x3414015a, 0xffffffff },
78 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
79 { 0xe4008200, 0xffffffff },
81 { 0x08000240, 0xffffffff },
85 #define HPPA_MAX_INSN_PATTERN_LEN (4)
87 /* Return non-zero if the instructions at PC match the series
88 described in PATTERN, or zero otherwise. PATTERN is an array of
89 'struct insn_pattern' objects, terminated by an entry whose mask is
92 When the match is successful, fill INSN[i] with what PATTERN[i]
95 insns_match_pattern (CORE_ADDR pc,
96 struct insn_pattern *pattern,
102 for (i = 0; pattern[i].mask; i++)
106 read_memory_nobpt (npc, buf, 4);
107 insn[i] = extract_unsigned_integer (buf, 4);
108 if ((insn[i] & pattern[i].mask) == pattern[i].data)
118 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
120 Unfortunately, because of various bugs and changes to the kernel,
121 we have several cases to deal with.
123 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
124 the beginning of the trampoline and struct rt_sigframe.
126 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
127 the 4th word in the trampoline structure. This is wrong, it should point
128 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
130 To detect these cases, we first take pc, align it to 64-bytes
131 to get the beginning of the signal frame, and then check offsets 0, 4
132 and 5 to see if we found the beginning of the trampoline. This will
133 tell us how to locate the sigcontext structure.
135 Note that with a 2.4 64-bit kernel, the signal context is not properly
136 passed back to userspace so the unwind will not work correctly. */
138 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
140 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
143 /* offsets to try to find the trampoline */
144 static int pcoffs[] = { 0, 4*4, 5*4 };
145 /* offsets to the rt_sigframe structure */
146 static int sfoffs[] = { 4*4, 10*4, 10*4 };
149 /* Most of the time, this will be correct. The one case when this will
150 fail is if the user defined an alternate stack, in which case the
151 beginning of the stack will not be align_down (pc, 64). */
152 sp = align_down (pc, 64);
154 /* rt_sigreturn trampoline:
155 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
156 3414015a ldi __NR_rt_sigreturn, %r20
157 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
160 for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
162 if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
171 if (insns_match_pattern (pc, hppa_sigtramp, dummy))
173 /* sigaltstack case: we have no way of knowing which offset to
174 use in this case; default to new kernel handling. If this is
175 wrong the unwinding will fail. */
177 sp = pc - pcoffs[try];
185 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
186 a struct siginfo and a struct ucontext. struct ucontext contains
187 a struct sigcontext. Return an offset to this sigcontext here. Too
188 bad we cannot include system specific headers :-(.
189 sizeof(struct siginfo) == 128
190 offsetof(struct ucontext, uc_mcontext) == 24. */
191 return sp + sfoffs[try] + 128 + 24;
194 struct hppa_linux_sigtramp_unwind_cache
197 struct trad_frame_saved_reg *saved_regs;
200 static struct hppa_linux_sigtramp_unwind_cache *
201 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
204 struct gdbarch *gdbarch = get_frame_arch (next_frame);
205 struct hppa_linux_sigtramp_unwind_cache *info;
212 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
214 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
216 pc = frame_pc_unwind (next_frame);
217 scptr = hppa_linux_sigtramp_find_sigcontext (pc);
219 /* structure of struct sigcontext:
222 unsigned long sc_flags;
223 unsigned long sc_gr[32];
224 unsigned long long sc_fr[32];
225 unsigned long sc_iasq[2];
226 unsigned long sc_iaoq[2];
227 unsigned long sc_sar; */
232 /* GR[0] is the psw, we don't restore that. */
235 /* General registers. */
236 for (i = 1; i < 32; i++)
238 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
245 /* FP regs; FP0-3 are not restored. */
248 for (i = 4; i < 32; i++)
250 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
252 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
257 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
259 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
262 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
264 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
267 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
273 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
274 void **this_prologue_cache,
275 struct frame_id *this_id)
277 struct hppa_linux_sigtramp_unwind_cache *info
278 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
279 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
283 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
284 void **this_prologue_cache,
285 int regnum, int *optimizedp,
286 enum lval_type *lvalp,
288 int *realnump, gdb_byte *valuep)
290 struct hppa_linux_sigtramp_unwind_cache *info
291 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
292 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
293 optimizedp, lvalp, addrp, realnump, valuep);
296 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
298 hppa_linux_sigtramp_frame_this_id,
299 hppa_linux_sigtramp_frame_prev_register
302 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
303 address should point to a signal trampoline on the stack. The signal
304 trampoline is embedded in a rt_sigframe structure that is aligned on
305 the stack. We take advantage of the fact that sp must be 64-byte aligned,
306 and the trampoline is small, so by rounding down the trampoline address
307 we can find the beginning of the struct rt_sigframe. */
308 static const struct frame_unwind *
309 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
311 CORE_ADDR pc = frame_pc_unwind (next_frame);
313 if (hppa_linux_sigtramp_find_sigcontext (pc))
314 return &hppa_linux_sigtramp_frame_unwind;
319 /* Attempt to find (and return) the global pointer for the given
322 This is a rather nasty bit of code searchs for the .dynamic section
323 in the objfile corresponding to the pc of the function we're trying
324 to call. Once it finds the addresses at which the .dynamic section
325 lives in the child process, it scans the Elf32_Dyn entries for a
326 DT_PLTGOT tag. If it finds one of these, the corresponding
327 d_un.d_ptr value is the global pointer. */
330 hppa_linux_find_global_pointer (struct value *function)
332 struct obj_section *faddr_sect;
335 faddr = value_as_address (function);
337 /* Is this a plabel? If so, dereference it to get the gp value. */
345 status = target_read_memory (faddr + 4, buf, sizeof (buf));
347 return extract_unsigned_integer (buf, sizeof (buf));
350 /* If the address is in the plt section, then the real function hasn't
351 yet been fixed up by the linker so we cannot determine the gp of
353 if (in_plt_section (faddr, NULL))
356 faddr_sect = find_pc_section (faddr);
357 if (faddr_sect != NULL)
359 struct obj_section *osect;
361 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
363 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
367 if (osect < faddr_sect->objfile->sections_end)
372 while (addr < osect->endaddr)
378 status = target_read_memory (addr, buf, sizeof (buf));
381 tag = extract_signed_integer (buf, sizeof (buf));
383 if (tag == DT_PLTGOT)
385 CORE_ADDR global_pointer;
387 status = target_read_memory (addr + 4, buf, sizeof (buf));
390 global_pointer = extract_unsigned_integer (buf, sizeof (buf));
393 return global_pointer;
407 * Registers saved in a coredump:
412 * sar, iir, isr, ior, ipsw
418 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n)
419 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n)
420 static const int greg_map[] =
422 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
423 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
424 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
425 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
426 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
427 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
428 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
429 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
431 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
432 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
434 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
435 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
437 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
438 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
440 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
441 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
443 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
444 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
448 hppa_linux_supply_regset (const struct regset *regset,
449 struct regcache *regcache,
450 int regnum, const void *regs, size_t len)
452 struct gdbarch *arch = get_regcache_arch (regcache);
453 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
454 const char *buf = regs;
458 for (i = 0; i < ARRAY_SIZE (greg_map); i++)
460 if (regnum == greg_map[i] || regnum == -1)
461 regcache_raw_supply (regcache, greg_map[i], buf + offset);
463 offset += tdep->bytes_per_address;
468 hppa_linux_supply_fpregset (const struct regset *regset,
469 struct regcache *regcache,
470 int regnum, const void *regs, size_t len)
472 const char *buf = regs;
476 for (i = 0; i < 31; i++)
478 if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
479 regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
485 /* HPPA Linux kernel register set. */
486 static struct regset hppa_linux_regset =
489 hppa_linux_supply_regset
492 static struct regset hppa_linux_fpregset =
495 hppa_linux_supply_fpregset
498 static const struct regset *
499 hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
500 const char *sect_name,
503 if (strcmp (sect_name, ".reg") == 0)
504 return &hppa_linux_regset;
505 else if (strcmp (sect_name, ".reg2") == 0)
506 return &hppa_linux_fpregset;
512 /* Forward declarations. */
513 extern initialize_file_ftype _initialize_hppa_linux_tdep;
516 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
518 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
520 /* GNU/Linux is always ELF. */
523 tdep->find_global_pointer = hppa_linux_find_global_pointer;
525 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
527 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
529 /* GNU/Linux uses SVR4-style shared libraries. */
530 set_solib_svr4_fetch_link_map_offsets
531 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
533 tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
534 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
536 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
537 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
539 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
540 some discussions to support 128-bit long double, but it requires some
541 more work in gcc and glibc first. */
542 set_gdbarch_long_double_bit (gdbarch, 64);
544 set_gdbarch_regset_from_core_section
545 (gdbarch, hppa_linux_regset_from_core_section);
548 /* Dwarf-2 unwinding support. Not yet working. */
549 set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
550 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
551 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
552 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
555 /* Enable TLS support. */
556 set_gdbarch_fetch_tls_load_module_address (gdbarch,
557 svr4_fetch_objfile_link_map);
561 _initialize_hppa_linux_tdep (void)
563 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
564 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi);