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"
34 #include "hppa-tdep.h"
36 #include "elf/common.h"
39 /* Convert DWARF register number REG to the appropriate register
40 number used by GDB. */
42 hppa_dwarf_reg_to_regnum (int reg)
44 /* registers 0 - 31 are the same in both sets */
48 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
49 if (reg >= 32 && reg <= 85)
50 return HPPA_FP4_REGNUM + (reg - 32);
52 warning (_("Unmapped DWARF Register #%d encountered."), reg);
58 hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
60 /* Probably this should be done by the kernel, but it isn't. */
61 write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid);
62 write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid);
65 /* An instruction to match. */
68 unsigned int data; /* See if it matches this.... */
69 unsigned int mask; /* ... with this mask. */
72 static struct insn_pattern hppa_sigtramp[] = {
73 /* ldi 0, %r25 or ldi 1, %r25 */
74 { 0x34190000, 0xfffffffd },
75 /* ldi __NR_rt_sigreturn, %r20 */
76 { 0x3414015a, 0xffffffff },
77 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
78 { 0xe4008200, 0xffffffff },
80 { 0x08000240, 0xffffffff },
84 #define HPPA_MAX_INSN_PATTERN_LEN (4)
86 /* Return non-zero if the instructions at PC match the series
87 described in PATTERN, or zero otherwise. PATTERN is an array of
88 'struct insn_pattern' objects, terminated by an entry whose mask is
91 When the match is successful, fill INSN[i] with what PATTERN[i]
94 insns_match_pattern (CORE_ADDR pc,
95 struct insn_pattern *pattern,
101 for (i = 0; pattern[i].mask; i++)
105 read_memory_nobpt (npc, buf, 4);
106 insn[i] = extract_unsigned_integer (buf, 4);
107 if ((insn[i] & pattern[i].mask) == pattern[i].data)
117 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
119 Unfortunately, because of various bugs and changes to the kernel,
120 we have several cases to deal with.
122 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
123 the beginning of the trampoline and struct rt_sigframe.
125 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
126 the 4th word in the trampoline structure. This is wrong, it should point
127 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
129 To detect these cases, we first take pc, align it to 64-bytes
130 to get the beginning of the signal frame, and then check offsets 0, 4
131 and 5 to see if we found the beginning of the trampoline. This will
132 tell us how to locate the sigcontext structure.
134 Note that with a 2.4 64-bit kernel, the signal context is not properly
135 passed back to userspace so the unwind will not work correctly. */
137 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
139 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
142 /* offsets to try to find the trampoline */
143 static int pcoffs[] = { 0, 4*4, 5*4 };
144 /* offsets to the rt_sigframe structure */
145 static int sfoffs[] = { 4*4, 10*4, 10*4 };
148 /* Most of the time, this will be correct. The one case when this will
149 fail is if the user defined an alternate stack, in which case the
150 beginning of the stack will not be align_down (pc, 64). */
151 sp = align_down (pc, 64);
153 /* rt_sigreturn trampoline:
154 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
155 3414015a ldi __NR_rt_sigreturn, %r20
156 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
159 for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
161 if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
170 if (insns_match_pattern (pc, hppa_sigtramp, dummy))
172 /* sigaltstack case: we have no way of knowing which offset to
173 use in this case; default to new kernel handling. If this is
174 wrong the unwinding will fail. */
176 sp = pc - pcoffs[try];
184 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
185 a struct siginfo and a struct ucontext. struct ucontext contains
186 a struct sigcontext. Return an offset to this sigcontext here. Too
187 bad we cannot include system specific headers :-(.
188 sizeof(struct siginfo) == 128
189 offsetof(struct ucontext, uc_mcontext) == 24. */
190 return sp + sfoffs[try] + 128 + 24;
193 struct hppa_linux_sigtramp_unwind_cache
196 struct trad_frame_saved_reg *saved_regs;
199 static struct hppa_linux_sigtramp_unwind_cache *
200 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
203 struct gdbarch *gdbarch = get_frame_arch (next_frame);
204 struct hppa_linux_sigtramp_unwind_cache *info;
211 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
213 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
215 pc = frame_pc_unwind (next_frame);
216 scptr = hppa_linux_sigtramp_find_sigcontext (pc);
218 /* structure of struct sigcontext:
221 unsigned long sc_flags;
222 unsigned long sc_gr[32];
223 unsigned long long sc_fr[32];
224 unsigned long sc_iasq[2];
225 unsigned long sc_iaoq[2];
226 unsigned long sc_sar; */
231 /* GR[0] is the psw, we don't restore that. */
234 /* General registers. */
235 for (i = 1; i < 32; i++)
237 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
244 /* FP regs; FP0-3 are not restored. */
247 for (i = 4; i < 32; i++)
249 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
251 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
256 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
258 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
261 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
263 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
266 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
272 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
273 void **this_prologue_cache,
274 struct frame_id *this_id)
276 struct hppa_linux_sigtramp_unwind_cache *info
277 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
278 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
282 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
283 void **this_prologue_cache,
284 int regnum, int *optimizedp,
285 enum lval_type *lvalp,
287 int *realnump, gdb_byte *valuep)
289 struct hppa_linux_sigtramp_unwind_cache *info
290 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
291 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
292 optimizedp, lvalp, addrp, realnump, valuep);
295 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
297 hppa_linux_sigtramp_frame_this_id,
298 hppa_linux_sigtramp_frame_prev_register
301 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
302 address should point to a signal trampoline on the stack. The signal
303 trampoline is embedded in a rt_sigframe structure that is aligned on
304 the stack. We take advantage of the fact that sp must be 64-byte aligned,
305 and the trampoline is small, so by rounding down the trampoline address
306 we can find the beginning of the struct rt_sigframe. */
307 static const struct frame_unwind *
308 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
310 CORE_ADDR pc = frame_pc_unwind (next_frame);
312 if (hppa_linux_sigtramp_find_sigcontext (pc))
313 return &hppa_linux_sigtramp_frame_unwind;
318 /* Attempt to find (and return) the global pointer for the given
321 This is a rather nasty bit of code searchs for the .dynamic section
322 in the objfile corresponding to the pc of the function we're trying
323 to call. Once it finds the addresses at which the .dynamic section
324 lives in the child process, it scans the Elf32_Dyn entries for a
325 DT_PLTGOT tag. If it finds one of these, the corresponding
326 d_un.d_ptr value is the global pointer. */
329 hppa_linux_find_global_pointer (struct value *function)
331 struct obj_section *faddr_sect;
334 faddr = value_as_address (function);
336 /* Is this a plabel? If so, dereference it to get the gp value. */
344 status = target_read_memory (faddr + 4, buf, sizeof (buf));
346 return extract_unsigned_integer (buf, sizeof (buf));
349 /* If the address is in the plt section, then the real function hasn't
350 yet been fixed up by the linker so we cannot determine the gp of
352 if (in_plt_section (faddr, NULL))
355 faddr_sect = find_pc_section (faddr);
356 if (faddr_sect != NULL)
358 struct obj_section *osect;
360 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
362 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
366 if (osect < faddr_sect->objfile->sections_end)
371 while (addr < osect->endaddr)
377 status = target_read_memory (addr, buf, sizeof (buf));
380 tag = extract_signed_integer (buf, sizeof (buf));
382 if (tag == DT_PLTGOT)
384 CORE_ADDR global_pointer;
386 status = target_read_memory (addr + 4, buf, sizeof (buf));
389 global_pointer = extract_unsigned_integer (buf, sizeof (buf));
392 return global_pointer;
406 * Registers saved in a coredump:
411 * sar, iir, isr, ior, ipsw
417 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n)
418 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n)
419 static const int greg_map[] =
421 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
422 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
423 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
424 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
425 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
426 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
427 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
428 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
430 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
431 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
433 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
434 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
436 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
437 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
439 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
440 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
442 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
443 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
447 hppa_linux_supply_regset (const struct regset *regset,
448 struct regcache *regcache,
449 int regnum, const void *regs, size_t len)
451 struct gdbarch *arch = get_regcache_arch (regcache);
452 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
453 const char *buf = regs;
457 for (i = 0; i < ARRAY_SIZE (greg_map); i++)
459 if (regnum == greg_map[i] || regnum == -1)
460 regcache_raw_supply (regcache, greg_map[i], buf + offset);
462 offset += tdep->bytes_per_address;
467 hppa_linux_supply_fpregset (const struct regset *regset,
468 struct regcache *regcache,
469 int regnum, const void *regs, size_t len)
471 const char *buf = regs;
475 for (i = 0; i < 31; i++)
477 if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
478 regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
484 /* HPPA Linux kernel register set. */
485 static struct regset hppa_linux_regset =
488 hppa_linux_supply_regset
491 static struct regset hppa_linux_fpregset =
494 hppa_linux_supply_fpregset
497 static const struct regset *
498 hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
499 const char *sect_name,
502 if (strcmp (sect_name, ".reg") == 0)
503 return &hppa_linux_regset;
504 else if (strcmp (sect_name, ".reg2") == 0)
505 return &hppa_linux_fpregset;
511 /* Forward declarations. */
512 extern initialize_file_ftype _initialize_hppa_linux_tdep;
515 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
517 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
519 /* GNU/Linux is always ELF. */
522 tdep->find_global_pointer = hppa_linux_find_global_pointer;
524 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
526 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
528 /* GNU/Linux uses SVR4-style shared libraries. */
529 set_solib_svr4_fetch_link_map_offsets
530 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
532 tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
533 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
535 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
536 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
538 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
539 some discussions to support 128-bit long double, but it requires some
540 more work in gcc and glibc first. */
541 set_gdbarch_long_double_bit (gdbarch, 64);
543 set_gdbarch_regset_from_core_section
544 (gdbarch, hppa_linux_regset_from_core_section);
547 /* Dwarf-2 unwinding support. Not yet working. */
548 set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
549 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
550 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
551 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
554 /* Enable TLS support. */
555 set_gdbarch_fetch_tls_load_module_address (gdbarch,
556 svr4_fetch_objfile_link_map);
560 _initialize_hppa_linux_tdep (void)
562 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
563 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi);