1 /* Target-dependent code for 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"
31 #include "hppa-tdep.h"
34 /* Convert DWARF register number REG to the appropriate register
35 number used by GDB. */
37 hppa_dwarf_reg_to_regnum (int reg
)
39 /* registers 0 - 31 are the same in both sets */
43 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
44 if (reg
>= 32 && reg
<= 85)
45 return HPPA_FP4_REGNUM
+ (reg
- 32);
47 warning ("Unmapped DWARF Register #%d encountered\n", reg
);
53 hppa_linux_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
55 /* Probably this should be done by the kernel, but it isn't. */
56 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, v
| 0x3, ptid
);
57 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, (v
+ 4) | 0x3, ptid
);
60 /* An instruction to match. */
63 unsigned int data
; /* See if it matches this.... */
64 unsigned int mask
; /* ... with this mask. */
67 /* See bfd/elf32-hppa.c */
68 static struct insn_pattern hppa_long_branch_stub
[] = {
70 { 0x20200000, 0xffe00000 },
71 /* be,n RR'xxx(%sr4,%r1) */
72 { 0xe0202002, 0xffe02002 },
76 static struct insn_pattern hppa_long_branch_pic_stub
[] = {
78 { 0xe8200000, 0xffe00000 },
79 /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
80 { 0x28200000, 0xffe00000 },
81 /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
82 { 0xe0202002, 0xffe02002 },
86 static struct insn_pattern hppa_import_stub
[] = {
87 /* addil LR'xxx, %dp */
88 { 0x2b600000, 0xffe00000 },
89 /* ldw RR'xxx(%r1), %r21 */
90 { 0x48350000, 0xffffb000 },
92 { 0xeaa0c000, 0xffffffff },
93 /* ldw RR'xxx+4(%r1), %r19 */
94 { 0x48330000, 0xffffb000 },
98 static struct insn_pattern hppa_import_pic_stub
[] = {
99 /* addil LR'xxx,%r19 */
100 { 0x2a600000, 0xffe00000 },
101 /* ldw RR'xxx(%r1),%r21 */
102 { 0x48350000, 0xffffb000 },
104 { 0xeaa0c000, 0xffffffff },
105 /* ldw RR'xxx+4(%r1),%r19 */
106 { 0x48330000, 0xffffb000 },
110 static struct insn_pattern hppa_plt_stub
[] = {
111 /* b,l 1b, %r20 - 1b is 3 insns before here */
112 { 0xea9f1fdd, 0xffffffff },
113 /* depi 0,31,2,%r20 */
114 { 0xd6801c1e, 0xffffffff },
118 static struct insn_pattern hppa_sigtramp
[] = {
119 /* ldi 0, %r25 or ldi 1, %r25 */
120 { 0x34190000, 0xfffffffd },
121 /* ldi __NR_rt_sigreturn, %r20 */
122 { 0x3414015a, 0xffffffff },
123 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
124 { 0xe4008200, 0xffffffff },
126 { 0x08000240, 0xffffffff },
130 #define HPPA_MAX_INSN_PATTERN_LEN (4)
132 /* Return non-zero if the instructions at PC match the series
133 described in PATTERN, or zero otherwise. PATTERN is an array of
134 'struct insn_pattern' objects, terminated by an entry whose mask is
137 When the match is successful, fill INSN[i] with what PATTERN[i]
140 insns_match_pattern (CORE_ADDR pc
,
141 struct insn_pattern
*pattern
,
147 for (i
= 0; pattern
[i
].mask
; i
++)
151 read_memory_nobpt (npc
, buf
, 4);
152 insn
[i
] = extract_unsigned_integer (buf
, 4);
153 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
162 hppa_linux_in_dyncall (CORE_ADDR pc
)
164 static CORE_ADDR dyncall
= 0;
166 /* FIXME: if we switch exec files, dyncall should be reinitialized */
169 struct minimal_symbol
*minsym
;
171 minsym
= lookup_minimal_symbol ("$$dyncall", NULL
, NULL
);
173 dyncall
= SYMBOL_VALUE_ADDRESS (minsym
);
178 return pc
== dyncall
;
181 /* There are several kinds of "trampolines" that we need to deal with:
182 - long branch stubs: these are inserted by the linker when a branch
183 target is too far away for a branch insn to reach
184 - plt stubs: these should go into the .plt section, so are easy to find
185 - import stubs: used to call from object to shared lib or shared lib to
186 shared lib; these go in regular text sections. In fact the linker tries
187 to put them throughout the code because branches have limited reachability.
188 We use the same mechanism as ppc64 to recognize the stub insn patterns.
189 - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function
190 calls. $$dyncall is exported by libgcc.a */
192 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
194 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
197 r
= in_plt_section (pc
, name
)
198 || hppa_linux_in_dyncall (pc
)
199 || insns_match_pattern (pc
, hppa_import_stub
, insn
)
200 || insns_match_pattern (pc
, hppa_import_pic_stub
, insn
)
201 || insns_match_pattern (pc
, hppa_long_branch_stub
, insn
)
202 || insns_match_pattern (pc
, hppa_long_branch_pic_stub
, insn
);
208 hppa_linux_skip_trampoline_code (CORE_ADDR pc
)
210 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
213 /* dyncall handles both PLABELs and direct addresses */
214 if (hppa_linux_in_dyncall (pc
))
216 pc
= (CORE_ADDR
) read_register (22);
218 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
220 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
225 dp_rel
= pic_rel
= 0;
226 if ((dp_rel
= insns_match_pattern (pc
, hppa_import_stub
, insn
))
227 || (pic_rel
= insns_match_pattern (pc
, hppa_import_pic_stub
, insn
)))
229 /* Extract the target address from the addil/ldw sequence. */
230 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
233 pc
+= (CORE_ADDR
) read_register (27);
235 pc
+= (CORE_ADDR
) read_register (19);
240 if (in_plt_section (pc
, NULL
))
242 pc
= (CORE_ADDR
) read_memory_integer (pc
, TARGET_PTR_BIT
/ 8);
244 /* if the plt slot has not yet been resolved, the target will
246 if (in_plt_section (pc
, NULL
))
248 /* Sanity check: are we pointing to the plt stub? */
249 if (insns_match_pattern (pc
, hppa_plt_stub
, insn
))
251 /* this should point to the fixup routine */
252 pc
= (CORE_ADDR
) read_memory_integer (pc
+ 8, TARGET_PTR_BIT
/ 8);
256 error ("Cannot resolve plt stub at 0x%s\n",
268 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
270 Unfortunately, because of various bugs and changes to the kernel,
271 we have several cases to deal with.
273 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
274 the beginning of the trampoline and struct rt_sigframe.
276 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
277 the 4th word in the trampoline structure. This is wrong, it should point
278 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
280 To detect these cases, we first take pc, align it to 64-bytes
281 to get the beginning of the signal frame, and then check offsets 0, 4
282 and 5 to see if we found the beginning of the trampoline. This will
283 tell us how to locate the sigcontext structure.
285 Note that with a 2.4 64-bit kernel, the signal context is not properly
286 passed back to userspace so the unwind will not work correctly. */
288 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc
)
290 unsigned int dummy
[HPPA_MAX_INSN_PATTERN_LEN
];
293 /* offsets to try to find the trampoline */
294 static int pcoffs
[] = { 0, 4*4, 5*4 };
295 /* offsets to the rt_sigframe structure */
296 static int sfoffs
[] = { 4*4, 10*4, 10*4 };
299 /* Most of the time, this will be correct. The one case when this will
300 fail is if the user defined an alternate stack, in which case the
301 beginning of the stack will not be align_down (pc, 64). */
302 sp
= align_down (pc
, 64);
304 /* rt_sigreturn trampoline:
305 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
306 3414015a ldi __NR_rt_sigreturn, %r20
307 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
310 for (try = 0; try < ARRAY_SIZE (pcoffs
); try++)
312 if (insns_match_pattern (sp
+ pcoffs
[try], hppa_sigtramp
, dummy
))
321 if (insns_match_pattern (pc
, hppa_sigtramp
, dummy
))
323 /* sigaltstack case: we have no way of knowing which offset to
324 use in this case; default to new kernel handling. If this is
325 wrong the unwinding will fail. */
327 sp
= pc
- pcoffs
[try];
335 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
336 a struct siginfo and a struct ucontext. struct ucontext contains
337 a struct sigcontext. Return an offset to this sigcontext here. Too
338 bad we cannot include system specific headers :-(.
339 sizeof(struct siginfo) == 128
340 offsetof(struct ucontext, uc_mcontext) == 24. */
341 return sp
+ sfoffs
[try] + 128 + 24;
344 struct hppa_linux_sigtramp_unwind_cache
347 struct trad_frame_saved_reg
*saved_regs
;
350 static struct hppa_linux_sigtramp_unwind_cache
*
351 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
354 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
355 struct hppa_linux_sigtramp_unwind_cache
*info
;
362 info
= FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache
);
364 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
366 pc
= frame_pc_unwind (next_frame
);
367 scptr
= hppa_linux_sigtramp_find_sigcontext (pc
);
369 /* structure of struct sigcontext:
372 unsigned long sc_flags;
373 unsigned long sc_gr[32];
374 unsigned long long sc_fr[32];
375 unsigned long sc_iasq[2];
376 unsigned long sc_iaoq[2];
377 unsigned long sc_sar; */
382 /* GR[0] is the psw, we don't restore that. */
385 /* General registers. */
386 for (i
= 1; i
< 32; i
++)
388 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= scptr
;
395 /* FP regs; FP0-3 are not restored. */
398 for (i
= 4; i
< 32; i
++)
400 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2)].addr
= scptr
;
402 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2) + 1].addr
= scptr
;
407 info
->saved_regs
[HPPA_PCSQ_HEAD_REGNUM
].addr
= scptr
;
409 info
->saved_regs
[HPPA_PCSQ_TAIL_REGNUM
].addr
= scptr
;
412 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= scptr
;
414 info
->saved_regs
[HPPA_PCOQ_TAIL_REGNUM
].addr
= scptr
;
417 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
423 hppa_linux_sigtramp_frame_this_id (struct frame_info
*next_frame
,
424 void **this_prologue_cache
,
425 struct frame_id
*this_id
)
427 struct hppa_linux_sigtramp_unwind_cache
*info
428 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
429 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
433 hppa_linux_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
434 void **this_prologue_cache
,
435 int regnum
, int *optimizedp
,
436 enum lval_type
*lvalp
,
438 int *realnump
, void *valuep
)
440 struct hppa_linux_sigtramp_unwind_cache
*info
441 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
442 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
443 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
446 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind
= {
448 hppa_linux_sigtramp_frame_this_id
,
449 hppa_linux_sigtramp_frame_prev_register
452 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
453 address should point to a signal trampoline on the stack. The signal
454 trampoline is embedded in a rt_sigframe structure that is aligned on
455 the stack. We take advantage of the fact that sp must be 64-byte aligned,
456 and the trampoline is small, so by rounding down the trampoline address
457 we can find the beginning of the struct rt_sigframe. */
458 static const struct frame_unwind
*
459 hppa_linux_sigtramp_unwind_sniffer (struct frame_info
*next_frame
)
461 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
463 if (hppa_linux_sigtramp_find_sigcontext (pc
))
464 return &hppa_linux_sigtramp_frame_unwind
;
469 /* Forward declarations. */
470 extern initialize_file_ftype _initialize_hppa_linux_tdep
;
473 hppa_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
475 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
477 /* Linux is always ELF. */
480 set_gdbarch_write_pc (gdbarch
, hppa_linux_target_write_pc
);
482 frame_unwind_append_sniffer (gdbarch
, hppa_linux_sigtramp_unwind_sniffer
);
484 /* GNU/Linux uses SVR4-style shared libraries. */
485 set_solib_svr4_fetch_link_map_offsets
486 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
488 set_gdbarch_in_solib_call_trampoline
489 (gdbarch
, hppa_linux_in_solib_call_trampoline
);
490 set_gdbarch_skip_trampoline_code
491 (gdbarch
, hppa_linux_skip_trampoline_code
);
493 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
494 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
497 /* Dwarf-2 unwinding support. Not yet working. */
498 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
499 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
500 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
501 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
506 _initialize_hppa_linux_tdep (void)
508 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_LINUX
, hppa_linux_init_abi
);