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
)
164 /* The relaxed version of the insn matcher allows us to match from somewhere
165 inside the pattern, by looking backwards in the instruction scheme. */
167 insns_match_pattern_relaxed (CORE_ADDR pc
,
168 struct insn_pattern
*pattern
,
174 while (pattern
[pat_len
].mask
)
177 for (offset
= 0; offset
< pat_len
; offset
++)
179 if (insns_match_pattern (pc
- offset
* 4,
188 hppa_linux_in_dyncall (CORE_ADDR pc
)
190 struct unwind_table_entry
*u
;
191 u
= find_unwind_entry (hppa_symbol_address ("$$dyncall"));
196 return pc
>= u
->region_start
&& pc
<= u
->region_end
;
199 /* There are several kinds of "trampolines" that we need to deal with:
200 - long branch stubs: these are inserted by the linker when a branch
201 target is too far away for a branch insn to reach
202 - plt stubs: these should go into the .plt section, so are easy to find
203 - import stubs: used to call from object to shared lib or shared lib to
204 shared lib; these go in regular text sections. In fact the linker tries
205 to put them throughout the code because branches have limited reachability.
206 We use the same mechanism as ppc64 to recognize the stub insn patterns.
207 - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function
208 calls. $$dyncall is exported by libgcc.a */
210 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
212 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
214 struct unwind_table_entry
*u
;
216 /* on hppa-linux, linker stubs have no unwind information. Since the pattern
217 matching for linker stubs can be quite slow, we try to avoid it if
219 u
= find_unwind_entry (pc
);
221 r
= in_plt_section (pc
, name
)
222 || hppa_linux_in_dyncall (pc
)
224 && (insns_match_pattern_relaxed (pc
, hppa_import_stub
, insn
)
225 || insns_match_pattern_relaxed (pc
, hppa_import_pic_stub
, insn
)
226 || insns_match_pattern_relaxed (pc
, hppa_long_branch_stub
, insn
)
227 || insns_match_pattern_relaxed (pc
, hppa_long_branch_pic_stub
, insn
)));
233 hppa_linux_skip_trampoline_code (CORE_ADDR pc
)
235 unsigned int insn
[HPPA_MAX_INSN_PATTERN_LEN
];
238 /* dyncall handles both PLABELs and direct addresses */
239 if (hppa_linux_in_dyncall (pc
))
241 pc
= (CORE_ADDR
) read_register (22);
243 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
245 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
250 dp_rel
= pic_rel
= 0;
251 if ((dp_rel
= insns_match_pattern (pc
, hppa_import_stub
, insn
))
252 || (pic_rel
= insns_match_pattern (pc
, hppa_import_pic_stub
, insn
)))
254 /* Extract the target address from the addil/ldw sequence. */
255 pc
= hppa_extract_21 (insn
[0]) + hppa_extract_14 (insn
[1]);
258 pc
+= (CORE_ADDR
) read_register (27);
260 pc
+= (CORE_ADDR
) read_register (19);
265 if (in_plt_section (pc
, NULL
))
267 pc
= (CORE_ADDR
) read_memory_integer (pc
, TARGET_PTR_BIT
/ 8);
269 /* if the plt slot has not yet been resolved, the target will
271 if (in_plt_section (pc
, NULL
))
273 /* Sanity check: are we pointing to the plt stub? */
274 if (insns_match_pattern (pc
, hppa_plt_stub
, insn
))
276 /* this should point to the fixup routine */
277 pc
= (CORE_ADDR
) read_memory_integer (pc
+ 8, TARGET_PTR_BIT
/ 8);
281 error ("Cannot resolve plt stub at 0x%s\n",
293 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
295 Unfortunately, because of various bugs and changes to the kernel,
296 we have several cases to deal with.
298 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
299 the beginning of the trampoline and struct rt_sigframe.
301 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
302 the 4th word in the trampoline structure. This is wrong, it should point
303 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
305 To detect these cases, we first take pc, align it to 64-bytes
306 to get the beginning of the signal frame, and then check offsets 0, 4
307 and 5 to see if we found the beginning of the trampoline. This will
308 tell us how to locate the sigcontext structure.
310 Note that with a 2.4 64-bit kernel, the signal context is not properly
311 passed back to userspace so the unwind will not work correctly. */
313 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc
)
315 unsigned int dummy
[HPPA_MAX_INSN_PATTERN_LEN
];
318 /* offsets to try to find the trampoline */
319 static int pcoffs
[] = { 0, 4*4, 5*4 };
320 /* offsets to the rt_sigframe structure */
321 static int sfoffs
[] = { 4*4, 10*4, 10*4 };
324 /* Most of the time, this will be correct. The one case when this will
325 fail is if the user defined an alternate stack, in which case the
326 beginning of the stack will not be align_down (pc, 64). */
327 sp
= align_down (pc
, 64);
329 /* rt_sigreturn trampoline:
330 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
331 3414015a ldi __NR_rt_sigreturn, %r20
332 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
335 for (try = 0; try < ARRAY_SIZE (pcoffs
); try++)
337 if (insns_match_pattern (sp
+ pcoffs
[try], hppa_sigtramp
, dummy
))
346 if (insns_match_pattern (pc
, hppa_sigtramp
, dummy
))
348 /* sigaltstack case: we have no way of knowing which offset to
349 use in this case; default to new kernel handling. If this is
350 wrong the unwinding will fail. */
352 sp
= pc
- pcoffs
[try];
360 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
361 a struct siginfo and a struct ucontext. struct ucontext contains
362 a struct sigcontext. Return an offset to this sigcontext here. Too
363 bad we cannot include system specific headers :-(.
364 sizeof(struct siginfo) == 128
365 offsetof(struct ucontext, uc_mcontext) == 24. */
366 return sp
+ sfoffs
[try] + 128 + 24;
369 struct hppa_linux_sigtramp_unwind_cache
372 struct trad_frame_saved_reg
*saved_regs
;
375 static struct hppa_linux_sigtramp_unwind_cache
*
376 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
379 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
380 struct hppa_linux_sigtramp_unwind_cache
*info
;
387 info
= FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache
);
389 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
391 pc
= frame_pc_unwind (next_frame
);
392 scptr
= hppa_linux_sigtramp_find_sigcontext (pc
);
394 /* structure of struct sigcontext:
397 unsigned long sc_flags;
398 unsigned long sc_gr[32];
399 unsigned long long sc_fr[32];
400 unsigned long sc_iasq[2];
401 unsigned long sc_iaoq[2];
402 unsigned long sc_sar; */
407 /* GR[0] is the psw, we don't restore that. */
410 /* General registers. */
411 for (i
= 1; i
< 32; i
++)
413 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= scptr
;
420 /* FP regs; FP0-3 are not restored. */
423 for (i
= 4; i
< 32; i
++)
425 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2)].addr
= scptr
;
427 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2) + 1].addr
= scptr
;
432 info
->saved_regs
[HPPA_PCSQ_HEAD_REGNUM
].addr
= scptr
;
434 info
->saved_regs
[HPPA_PCSQ_TAIL_REGNUM
].addr
= scptr
;
437 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= scptr
;
439 info
->saved_regs
[HPPA_PCOQ_TAIL_REGNUM
].addr
= scptr
;
442 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
448 hppa_linux_sigtramp_frame_this_id (struct frame_info
*next_frame
,
449 void **this_prologue_cache
,
450 struct frame_id
*this_id
)
452 struct hppa_linux_sigtramp_unwind_cache
*info
453 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
454 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
458 hppa_linux_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
459 void **this_prologue_cache
,
460 int regnum
, int *optimizedp
,
461 enum lval_type
*lvalp
,
463 int *realnump
, void *valuep
)
465 struct hppa_linux_sigtramp_unwind_cache
*info
466 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
467 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
468 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
471 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind
= {
473 hppa_linux_sigtramp_frame_this_id
,
474 hppa_linux_sigtramp_frame_prev_register
477 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
478 address should point to a signal trampoline on the stack. The signal
479 trampoline is embedded in a rt_sigframe structure that is aligned on
480 the stack. We take advantage of the fact that sp must be 64-byte aligned,
481 and the trampoline is small, so by rounding down the trampoline address
482 we can find the beginning of the struct rt_sigframe. */
483 static const struct frame_unwind
*
484 hppa_linux_sigtramp_unwind_sniffer (struct frame_info
*next_frame
)
486 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
488 if (hppa_linux_sigtramp_find_sigcontext (pc
))
489 return &hppa_linux_sigtramp_frame_unwind
;
494 /* Attempt to find (and return) the global pointer for the given
497 This is a rather nasty bit of code searchs for the .dynamic section
498 in the objfile corresponding to the pc of the function we're trying
499 to call. Once it finds the addresses at which the .dynamic section
500 lives in the child process, it scans the Elf32_Dyn entries for a
501 DT_PLTGOT tag. If it finds one of these, the corresponding
502 d_un.d_ptr value is the global pointer. */
505 hppa_linux_find_global_pointer (struct value
*function
)
507 struct obj_section
*faddr_sect
;
510 faddr
= value_as_address (function
);
512 /* Is this a plabel? If so, dereference it to get the gp value. */
520 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
522 return extract_unsigned_integer (buf
, sizeof (buf
));
525 /* If the address is in the plt section, then the real function hasn't
526 yet been fixed up by the linker so we cannot determine the gp of
528 if (in_plt_section (faddr
, NULL
))
531 faddr_sect
= find_pc_section (faddr
);
532 if (faddr_sect
!= NULL
)
534 struct obj_section
*osect
;
536 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
538 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
542 if (osect
< faddr_sect
->objfile
->sections_end
)
547 while (addr
< osect
->endaddr
)
553 status
= target_read_memory (addr
, buf
, sizeof (buf
));
556 tag
= extract_signed_integer (buf
, sizeof (buf
));
558 if (tag
== DT_PLTGOT
)
560 CORE_ADDR global_pointer
;
562 status
= target_read_memory (addr
+ 4, buf
, sizeof (buf
));
565 global_pointer
= extract_unsigned_integer (buf
, sizeof (buf
));
568 return global_pointer
;
581 /* Forward declarations. */
582 extern initialize_file_ftype _initialize_hppa_linux_tdep
;
585 hppa_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
587 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
589 /* GNU/Linux is always ELF. */
592 tdep
->find_global_pointer
= hppa_linux_find_global_pointer
;
594 set_gdbarch_write_pc (gdbarch
, hppa_linux_target_write_pc
);
596 frame_unwind_append_sniffer (gdbarch
, hppa_linux_sigtramp_unwind_sniffer
);
598 /* GNU/Linux uses SVR4-style shared libraries. */
599 set_solib_svr4_fetch_link_map_offsets
600 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
602 tdep
->in_solib_call_trampoline
= hppa_linux_in_solib_call_trampoline
;
603 set_gdbarch_skip_trampoline_code
604 (gdbarch
, hppa_linux_skip_trampoline_code
);
606 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
607 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
609 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
610 some discussions to support 128-bit long double, but it requires some
611 more work in gcc and glibc first. */
612 set_gdbarch_long_double_bit (gdbarch
, 64);
615 /* Dwarf-2 unwinding support. Not yet working. */
616 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
617 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
618 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
619 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
624 _initialize_hppa_linux_tdep (void)
626 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_LINUX
, hppa_linux_init_abi
);